sygnal 5.3.7 → 6.0.0

package/dist/diagnostics.esm.js

@@ -0,0 +1,4003 @@
+import * as ns from 'xstream';
+import { MemoryStream, NO, NO_IL, Stream as Stream$1 } from 'xstream';
+import 'sygnal';
+
+const d = ns.default;
+const xs$1 = d && typeof d.create === 'function' ? d : d && d.default && typeof d.default.create === 'function' ? d.default : ns;
+
+var xstreamNamespace = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    MemoryStream: MemoryStream,
+    NO: NO,
+    NO_IL: NO_IL,
+    Stream: Stream$1,
+    default: xs$1
+});
+
+function resolveInteropDefault(namespaceValue) {
+    if (namespaceValue &&
+        namespaceValue.default &&
+        namespaceValue.default.default &&
+        typeof namespaceValue.default.default === 'function') {
+        return namespaceValue.default.default;
+    }
+    if (namespaceValue && namespaceValue.default) {
+        return namespaceValue.default;
+    }
+    return namespaceValue;
+}
+function getXs(namespaceValue) {
+    const value = resolveInteropDefault(namespaceValue);
+    if (value &&
+        value.default &&
+        typeof value.default.create === 'function') {
+        return value.default;
+    }
+    return value;
+}
+const xs = getXs(xstreamNamespace);
+const Stream = Stream$1 ||
+    (xs$1 && xs$1.Stream) ||
+    (xs && xs.Stream);
+
+const DOCS_BASE_URL = 'https://sygnal.js.org';
+const CODE_SEVERITY = {
+    SYG101: 'warn',
+    SYG102: 'info',
+    SYG103: 'info',
+    SYG104: 'warn',
+    SYG105: 'info',
+    SYG106: 'warn',
+    SYG110: 'warn',
+    SYG111: 'warn',
+    SYG201: 'warn',
+    SYG202: 'warn',
+    SYG301: 'error',
+    SYG401: 'warn',
+    SYG900: 'warn',
+    // ---- 1E retrofit codes (SYG206-299, 402-499, 601-699, 901-999) ----
+    SYG206: 'error',
+    SYG207: 'warn',
+    SYG208: 'warn',
+    SYG209: 'error',
+    SYG210: 'warn',
+    SYG211: 'error',
+    SYG212: 'error',
+    SYG213: 'warn',
+    SYG214: 'error',
+    SYG215: 'error',
+    SYG216: 'error',
+    SYG217: 'warn',
+    SYG218: 'error',
+    SYG219: 'warn',
+    SYG220: 'warn',
+    SYG402: 'error',
+    SYG403: 'error',
+    SYG404: 'error',
+    SYG405: 'error',
+    SYG406: 'error',
+    SYG407: 'error',
+    SYG408: 'error',
+    SYG409: 'warn',
+    SYG410: 'error',
+    SYG411: 'error',
+    SYG412: 'error',
+    SYG413: 'error',
+    SYG414: 'error',
+    SYG415: 'error',
+    SYG416: 'error',
+    SYG417: 'warn',
+    SYG418: 'error',
+    SYG419: 'error',
+    SYG420: 'error',
+    SYG601: 'error',
+    SYG602: 'error',
+    SYG603: 'error',
+    SYG604: 'error',
+    SYG605: 'error',
+    SYG606: 'error',
+    SYG607: 'error',
+    SYG608: 'warn',
+    SYG609: 'warn',
+    SYG610: 'error',
+    SYG901: 'error',
+    SYG902: 'error',
+    SYG903: 'error',
+    // ---- end 1E retrofit codes ----
+};
+const CODE_TITLES = {
+    // SYG1xx wiring (1A)
+    SYG101: 'Intent action has no model entry',
+    SYG102: 'Model entry is unreachable',
+    SYG103: 'Intent selector matched no rendered element',
+    SYG104: 'Intent selector crosses an isolation boundary',
+    SYG105: 'EVENTS type selected but never emitted, or emitted but never selected',
+    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',
+    // SYG3xx streams & intent construction (1A)
+    SYG301: 'RxJS operator used on an xstream stream',
+    // 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: "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: "Removed in 6.0: 'ACTION | SINK' model key",
+    SYG505: 'Non-canonical EVENTS emit',
+    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) ----
+    SYG206: 'Invalid calculated field definition',
+    SYG207: 'Calculated field shadows an initialState key',
+    SYG208: 'Calculated field depends on an unknown key',
+    SYG209: 'Circular calculated field dependency',
+    SYG210: 'INITIALIZE used with a sink other than STATE',
+    SYG211: "Retired in 6.0: Invalid model shorthand entry",
+    SYG212: 'Model entry is not a function or an object of sinks',
+    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',
+    SYG217: 'Driver-sink reducer returned undefined',
+    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',
+    SYG405: 'Sub-component has initialState without isolatedState',
+    SYG406: 'View threw',
+    SYG407: 'onError handler threw',
+    SYG408: 'Sub-component failed to instantiate',
+    SYG409: 'Child tried to update a calculated field',
+    SYG410: "Invalid sub-component 'state' prop",
+    SYG411: "Collection 'of' is missing or not a component",
+    SYG412: "Invalid Collection 'from' prop",
+    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: "Retired in 6.0: Invalid switchable() 'name$' parameter",
+    SYG420: 'JSX tag is undefined',
+    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: "Retired in 6.0: Invalid hmrActions",
+    SYG605: "Retired in 6.0: Intent action name contains '|'",
+    SYG606: 'calculated is not an object',
+    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 ----
+};
+// 2A: strict-mode (SYG5xx) default severities. Kept OUT of CODE_SEVERITY so the
+// main bundle doesn't carry them (D29: zero bytes); the 'sygnal/diagnostics'
+// entry registers them (registerCodes) and its reports pass the severity
+// explicitly. sygnal-check keeps the same table in sygnal-check/src/codes.js.
+const STRICT_CODE_SEVERITY = {
+    SYG501: 'error',
+    SYG502: 'warn',
+    SYG503: 'warn',
+    SYG504: 'error',
+    SYG505: '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.
+const DEV_CODE_SEVERITY = {
+    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',
+};
+function getCodeInfo(code) {
+    const severity = CODE_SEVERITY[code];
+    return severity && { code, severity, title: CODE_TITLES[code] || '', docsSlug: code.toLowerCase() };
+}
+function listCodes() {
+    return Object.keys(CODE_SEVERITY).map(c => getCodeInfo(c));
+}
+function registerCodes(entries) {
+    for (const [code, severity, title] of entries) {
+        CODE_SEVERITY[code] = severity;
+        CODE_TITLES[code] = title;
+    }
+}
+function docsUrlFor(code) {
+    return `${DOCS_BASE_URL}/reference/errors#${code.toLowerCase()}`;
+}
+
+/**
+ * Shared plumbing for the runtime checks (PLAN-1 workstream 1A).
+ *
+ * The checks are bundled separately from the main 'sygnal' entry
+ * ('sygnal/diagnostics'). They must talk to the SAME diagnostics core
+ * instance the components use, so they never import the core's functions
+ * directly: `import '../index'` only makes sure the core is loaded (in the
+ * dist build that import is rewritten to the external 'sygnal' package, see
+ * rollup.config.mjs), and the functions are read from the bridge object the
+ * core publishes on globalThis.__SYGNAL_DIAGNOSTICS__.
+ */
+const bridge = () => globalThis.__SYGNAL_DIAGNOSTICS__;
+const report = (code, details) => bridge().report(code, details);
+/**
+ * report() for code that is NOT running inside a core hook (timers, wrapped
+ * methods): never throws synchronously; an 'error'-mode DiagnosticError is
+ * rethrown asynchronously, like the core does for hooks.
+ */
+const reportSafely = (code, details) => {
+    try {
+        return report(code, details);
+    }
+    catch (err) {
+        const raise = () => { throw err; };
+        typeof queueMicrotask === 'function' ? queueMicrotask(raise) : setTimeout(raise);
+        return undefined;
+    }
+};
+registerCodes(Object.keys(DEV_CODE_SEVERITY).map(code => [code, DEV_CODE_SEVERITY[code], CODE_TITLES[code]]));
+/**
+ * reportSafely() for the dev-entry-only codes (DEV_CODE_SEVERITY, G-143): the main bundle's
+ * core doesn't know their severity, so it is passed explicitly.
+ */
+const devReport = (code, details) => reportSafely(code, { severity: DEV_CODE_SEVERITY[code], ...details });
+/** Tunables (test seam: configureChecks()). */
+const timing = {
+    /** delay after a render before DOM checks run (lets nested renders patch) */
+    settleMs: 50,
+    /** SYG103 escalates to warn after this much render-idle time ... */
+    idleMs: 2000,
+    /** ... and only once the component has rendered at least this often */
+    minRenders: 3,
+};
+/**
+ * Built-in actions Sygnal dispatches itself; never "missing" or "unreachable".
+ * (HYDRATE is not one since 6.0, D66: nothing dispatches it, so it is an ordinary action.)
+ */
+const BUILTIN_ACTIONS = new Set(['BOOTSTRAP', 'INITIALIZE', 'DISPOSE', 'READY', 'RESOURCE']);
+/** Sinks the core handles itself: their values never go to a reply-action driver. */
+// (PLAN-4 GS-2: ELEMENT too; `{ scrollIntoView: Row, block: 'center' }` names no action)
+const NON_REPLY_SINK = /^(STATE|EFFECT|EVENTS|PARENT|READY|DOM|CHILD|ELEMENT|PERSIST)$/;
+// `ok: 'X'` / `"error": "X"` in function source (minified code keeps string literals and keys)
+const keyedNames = (keys) => new RegExp(`(?:^|[{,\\s])["']?(?:${keys})["']?\\s*:\\s*(["'\`])([\\w$.:/-]+)\\1`, 'g');
+// (PLAN-3 5-4b: and a router `{ block: 'ACTION' }`)
+const REPLY_IN_SOURCE = keyedNames('ok|error|block');
+const CONNECTION_IN_SOURCE = keyedNames('message|open|close|error');
+// G-224: a `timers` static's `action: 'TICK'` / `frame: 'FRAME'`
+const TIMER_IN_SOURCE = keyedNames('action|frame');
+// PLAN-5 B-3: a `browser` static's `action: 'SEEN'` / `error: 'GEO_FAILED'`
+const BROWSER_IN_SOURCE = keyedNames('action|error');
+const namesIn = (fn, re, out) => {
+    if (typeof fn !== 'function')
+        return;
+    let src = '';
+    try {
+        src = Function.prototype.toString.call(fn);
+    }
+    catch (_) {
+        return;
+    }
+    re.lastIndex = 0;
+    for (let m = re.exec(src); m; m = re.exec(src))
+        out.add(m[2]);
+};
+/**
+ * Reply actions a component's requests and `connections` static can name, read from the
+ * source of its non-STATE sink functions (`HTTP: (s) => ({ url, ok: 'LOADED', error: 'FAILED' })`)
+ * and of `connections` (message/open/close/error). A heuristic for SYG102 (PLAN-3): a name
+ * built at run time is missed (SYG102 stays info, so that only costs a false hint).
+ */
+function replyNamesOf(component) {
+    const out = new Set();
+    const model = component && component.model;
+    if (model && typeof model === 'object') {
+        for (const key of Object.keys(model)) {
+            const value = model[key];
+            const bar = key.indexOf('|');
+            if (bar >= 0) {
+                if (!NON_REPLY_SINK.test(key.slice(bar + 1).trim()))
+                    namesIn(value, REPLY_IN_SOURCE, out);
+            }
+            else if (value && typeof value === 'object') {
+                for (const sink of Object.keys(value)) {
+                    if (!NON_REPLY_SINK.test(sink))
+                        namesIn(value[sink], REPLY_IN_SOURCE, out);
+                }
+            }
+        }
+    }
+    namesIn(component?.view?.connections, CONNECTION_IN_SOURCE, out);
+    // G-224: makeTimerDriver() replies the actions the `timers` static names (a function of the
+    // state, or an object of them)
+    const timers = component?.view?.timers;
+    if (timers && typeof timers === 'object')
+        for (const k in timers)
+            namesIn(timers[k], TIMER_IN_SOURCE, out);
+    else
+        namesIn(timers, TIMER_IN_SOURCE, out);
+    // PLAN-5 B-3: the browser driver replies the actions the `browser` static names
+    const browser = component?.view?.browser;
+    if (browser && typeof browser === 'object')
+        for (const k in browser)
+            namesIn(browser[k], BROWSER_IN_SOURCE, out);
+    else
+        namesIn(browser, BROWSER_IN_SOURCE, out);
+    // PLAN-3 5-4b: the router replies the action a `route` static names
+    const route = component?.view?.route;
+    if (typeof route === 'string')
+        out.add(route);
+    // PLAN-4 GS-5: persist() adds RESTORE (sent after hydration and by sync)
+    if (component?.view?.persist)
+        out.add('RESTORE');
+    return out;
+}
+/** Reply actions a component instance's requests were seen naming (replies.ts → inspect). */
+const replySeen = new WeakMap();
+/** Synthetic/internal actions (`__TEST_ACTION__`, `__NOOP_ACTION__`, ...) and built-ins. */
+const isInternalAction = (action) => typeof action !== 'string' || action.startsWith('__') || BUILTIN_ACTIONS.has(action);
+let seen = new Set();
+/** true the first time `key` is seen (dedupes reports, e.g. per component name). */
+const once = (key) => (seen.has(key) ? false : (seen.add(key), true));
+/** undo once(key): the report it guarded wasn't made (G-470: diagnostics off) */
+const unsee = (key) => void seen.delete(key);
+/** whether once(`key`) has reported already (a check can skip its work: SYG435) */
+const onced = (key) => seen.has(key);
+/**
+ * Forget only the once() dedupe set (G-051: renderComponent calls it through the core bridge
+ * when an outermost instance starts, so findings are reported again in every test). Unlike
+ * resetCheckState() it keeps the checks' registries, e.g. inspect()'s live records.
+ */
+const resetOnce = () => { seen = new Set(); };
+{
+    const core = bridge();
+    if (core)
+        core.resetOnce = resetOnce;
+}
+const resetters = [];
+const onReset = (fn) => { resetters.push(fn); };
+/** Clear every check's dedupe/registry state (tests). */
+function resetCheckState() {
+    seen = new Set();
+    resetters.forEach(fn => fn());
+}
+const nameOf = (component) => (component && component.name) || 'component';
+const isPlainObject = (value) => !!value && typeof value === 'object' && !Array.isArray(value) &&
+    (Object.getPrototypeOf(value) === Object.prototype || Object.getPrototypeOf(value) === null);
+/** Levenshtein distance (small strings only). */
+function distance$1(a, b) {
+    const row = Array.from({ length: b.length + 1 }, (_, i) => i);
+    for (let i = 1; i <= a.length; i++) {
+        let prev = row[0];
+        row[0] = i;
+        for (let j = 1; j <= b.length; j++) {
+            const tmp = row[j];
+            row[j] = Math.min(row[j] + 1, row[j - 1] + 1, prev + (a[i - 1] === b[j - 1] ? 0 : 1));
+            prev = tmp;
+        }
+    }
+    return row[b.length];
+}
+/** Closest candidate to `name` (case-insensitive match or edit distance <= 2), if any. */
+function suggest(name, candidates) {
+    let best;
+    let bestScore = Infinity;
+    for (const c of candidates) {
+        if (c === name)
+            continue;
+        const score = c.toLowerCase() === name.toLowerCase() ? 0 : distance$1(c, name);
+        if (score < bestScore) {
+            best = c;
+            bestScore = score;
+        }
+    }
+    return bestScore <= Math.min(2, Math.floor(name.length / 3)) ? best : undefined;
+}
+const didYouMean = (name, candidates) => {
+    const s = suggest(name, candidates);
+    return s ? ` (did you mean '${s}'?)` : '';
+};
+
+const intentActions = new WeakMap();
+// 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) => {
+    const dom = c?.sources?.[c.DOMSourceName || 'DOM'];
+    return !!dom && typeof dom == 'object' && '_hub' in dom;
+};
+const driverFix = (sink) => `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`;
+const wiringCheck = {
+    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, k) {
+                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(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((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 },
+            });
+        }
+    },
+};
+
+/*
+ * Tiny helpers shared by the core and the helper modules (behaviors, undo, the dev entry), kept
+ * out of the core so importing them never pulls it in.
+ */
+/** The "no change / send nothing" sentinel (a registered symbol: the same in every copy) */
+/**
+ * Whether a value is ABORT. Compares the description, not the identity, in case bundlers (e.g.
+ * Vite) create duplicate module instances with separate Symbol.for() registries. (G-214: the
+ * one copy, for the core, behaviors, undo and the action log)
+ */
+const isAbort = (v) => typeof v == 'symbol' && v.description == 'sygnal.ABORT';
+/**
+ * Set on a dev-only wrapper of a model function (SYG222's) to the function it wraps, so the
+ * action log and t.explain() show the user's reducer (G-214 follow-up)
+ */
+const ORIGINAL = Symbol.for('sygnal.original');
+
+const SKIP = new Set(['INITIALIZE']);
+// SYG222: the instance's STATE reducers, wrapped (see the header)
+const WRAPPED$1 = Symbol('SYG222');
+function watchMutation(component, action, fn) {
+    if (typeof fn !== 'function' || fn[WRAPPED$1])
+        return fn;
+    const wrapped = (state, ...rest) => {
+        if (!isPlainObject(state))
+            return fn(state, ...rest);
+        // the state's top level, and (G-214) each behavior slice's: a behavior reducer that mutates
+        // its slice gets the host state back unchanged (behaviors.ts), so state[key] looks the same
+        const snaps = [[state, ''], ...(component._uses || []).map(([k]) => [state[k], k + '.'])]
+            .filter(([o]) => isPlainObject(o)).map(([o, p]) => [o, p, Object.keys(o), Object.values(o)]);
+        const out = fn(state, ...rest);
+        if (out === state) {
+            const changed = snaps.flatMap(([o, p, keys, values]) => keys.filter((k, i) => !(k in o) || o[k] !== values[i])
+                .concat(Object.keys(o).filter(k => !keys.includes(k))).map((k) => p + k));
+            const name = nameOf(component);
+            if (changed.length && once(`SYG222:${name}:${action}`)) {
+                const list = changed.map(k => `'${k}'`).join(', ');
+                devReport('SYG222', {
+                    component,
+                    message: `The STATE reducer for '${action}' changed ${list} in place and returned the same object. Returning the object a reducer got means "no change" (as ABORT), so the change is ignored and nothing re-renders`,
+                    fix: `Return a new object: ${changed[0].includes('.') ? `(slice, data) => ({ ...slice, ${changed[0].split('.')[1]}: … })` : `(state, data) => ({ ...state, ${changed[0]}: … })`}. To write updates as mutations, wrap the reducer in immer's produce()`,
+                    data: { action, keys: changed },
+                });
+            }
+        }
+        return out;
+    };
+    wrapped[WRAPPED$1] = true;
+    // checks that read reducer source (reply actions) see the original; so do the action log
+    // and t.explain() (ORIGINAL)
+    wrapped.toString = () => fn.toString();
+    wrapped[ORIGINAL] = fn;
+    return wrapped;
+}
+const stateCheck = {
+    id: 'state',
+    // SYG222: checks/next.ts wraps the STATE reducers (watchMutation) through wrapHandler
+    onModel(component) {
+        // SYG238 (G-393): the initial state is set at construction (D165), before onModel
+        const n = component?.__next;
+        if (!n?.isRoot || !n.def?.model || n.state !== undefined)
+            return;
+        const name = nameOf(component);
+        if (!once(`SYG238:${name}`))
+            return;
+        devReport('SYG238', {
+            component,
+            message: `${name} is a root with a model but no initialState: its state is undefined, so it renders nothing until an action sets one`,
+            fix: `Add ${name}.initialState = { … } (the root's start state; a child gets its state from its parent instead)`,
+            data: {},
+        });
+    },
+    onReducer(component, action, prevState, nextState) {
+        if (typeof action !== 'string' || action.startsWith('__') || SKIP.has(action))
+            return;
+        const name = nameOf(component);
+        if (nextState === undefined) {
+            // G-357: returning undefined from a Collection item's reducer is the documented way to
+            // remove the item: not reported. In another sub-component it is info, in the root (where
+            // it wipes the whole app state) a warning.
+            if (component?.__next?.kind === 'item' || !once(`SYG202:${name}:${action}`))
+                return;
+            const sub = !!component?.isSubComponent;
+            report('SYG202', {
+                component,
+                severity: sub ? 'info' : 'warn',
+                message: `The STATE reducer for '${action}' returned undefined` +
+                    (sub ? ' (only a Collection item removes itself this way)' : ''),
+                fix: `Return the new state, e.g. (state, data) => ({ ...state, ... }), or return ABORT to leave the state unchanged`,
+                data: { action },
+            });
+            return;
+        }
+        if (!isPlainObject(prevState) || !isPlainObject(nextState))
+            return;
+        // SYG221 (G-143): set('city') spreads the string into the state: { ...state, 0: 'c', 1: 'i', ... }
+        const chars = [];
+        while (typeof nextState[chars.length] === 'string' && nextState[chars.length].length === 1 && !(chars.length in prevState)) {
+            chars.push(nextState[chars.length]);
+        }
+        if (chars.length > 0 && !(chars.length in nextState)) {
+            if (!once(`SYG221:${name}:${action}`))
+                return;
+            const field = chars.join('');
+            const update = /^[A-Za-z_$][\w$]*$/.test(field)
+                ? `set((state, ${field}) => ({ ${field} }))`
+                : `set((state, value) => ({ ['${field}']: value }))`;
+            devReport('SYG221', {
+                component,
+                message: `The STATE reducer for '${action}' added the keys ${chars.map((_, i) => `'${i}'`).slice(0, 4).join(', ')}${chars.length > 4 ? ', …' : ''} ` +
+                    `(one per character of '${field}'): set() was called with a string, set('${field}'). set() takes an object or a function`,
+                fix: `To store the action data in '${field}', pass a function: ${update}. For a fixed value pass an object: set({ ${field}: … })`,
+                data: { action, field },
+            });
+            return;
+        }
+        const calculated = component?._calculatedFieldNames || null;
+        const dropped = Object.keys(prevState).filter(key => !(key in nextState) && prevState[key] !== undefined && !(calculated && calculated.has(key)));
+        if (dropped.length === 0 || !once(`SYG201:${name}:${action}`))
+            return;
+        const list = dropped.map(k => `'${k}'`).join(', ');
+        report('SYG201', {
+            component,
+            message: `The STATE reducer for '${action}' returned a state without ${list}, which ${dropped.length === 1 ? 'was' : 'were'} in the previous state (likely a missing ...state spread)`,
+            fix: `Spread the previous state: (state, data) => ({ ...state, ... }). If removing ${dropped.length === 1 ? 'the key' : 'these keys'} is intended, ignore this`,
+            data: { action, droppedKeys: dropped },
+        });
+    },
+};
+
+let selected$1 = new Set();
+let emitted = new Set();
+let selectsAll = false;
+onReset(() => { selected$1 = new Set(); emitted = new Set(); selectsAll = false; });
+const eventsCheck = {
+    id: 'events',
+    onBusSelect(type) {
+        if (type === undefined || type === null || type === '') {
+            selectsAll = true;
+            return;
+        }
+        for (const t of [].concat(type))
+            if (typeof t === 'string')
+                selected$1.add(t);
+    },
+    onBusEmit(type, emitterName) {
+        if (typeof type !== 'string') {
+            // SYG116 (G-143): no EVENTS.select() can ever receive it. The core copies each emitted
+            // value into a new object (devtools stamp), so a function arrives here as {}.
+            if (once(`SYG116:${emitterName}`)) {
+                devReport('SYG116', {
+                    component: emitterName,
+                    message: `${emitterName ? emitterName + "'s model" : 'A model'} sent a value with no string 'type' to the EVENTS sink, so nothing receives it. ` +
+                        `The value was probably a function (a model entry that returns event(...) instead of being event(...)), or undefined/null`,
+                    fix: `Make event() the sink entry itself: ACTION: { EVENTS: event('TYPE', (state, data) => payload) }; return ABORT to send nothing`,
+                    data: { type, emitter: emitterName },
+                });
+            }
+            return;
+        }
+        emitted.add(type);
+        if (selectsAll || selected$1.has(type) || !once(`SYG105:emit:${type}`))
+            return;
+        report('SYG105', {
+            component: emitterName,
+            message: `EVENTS event '${type}' was emitted, but nothing selects it, so it was dropped${didYouMean(type, selected$1)}`,
+            fix: `Subscribe with EVENTS.select('${type}') in the component that should react, or check the event name`,
+            data: { type, direction: 'emitted-not-selected', emitter: emitterName },
+        });
+    },
+};
+/**
+ * Report SYG105 (info) for every EVENTS type that has been selected but never
+ * emitted so far, and return the bus registry. Intended for inspect tooling and
+ * tests, at a point where the session is "done".
+ */
+function checkEventBus() {
+    const selectedNeverEmitted = [...selected$1].filter(t => !emitted.has(t));
+    const emittedNeverSelected = selectsAll ? [] : [...emitted].filter(t => !selected$1.has(t));
+    for (const type of selectedNeverEmitted) {
+        if (!once(`SYG105:select:${type}`))
+            continue;
+        report('SYG105', {
+            message: `EVENTS.select('${type}') is used, but no component has emitted '${type}'${didYouMean(type, emitted)}`,
+            fix: `Emit it from a model entry, e.g. { EVENTS: event('${type}', ...) }, or check the event name`,
+            data: { type, direction: 'selected-not-emitted' },
+        });
+    }
+    return { selected: [...selected$1], emitted: [...emitted], selectedNeverEmitted, emittedNeverSelected };
+}
+
+registerCodes(Object.keys(STRICT_CODE_SEVERITY).map(code => [code, STRICT_CODE_SEVERITY[code], CODE_TITLES[code]]));
+/**
+ * Turn runtime strict checks on (true), off (false), or back to the default
+ * (undefined → globalThis.__SYGNAL_STRICT__ === true).
+ */
+function configureStrict(on) {
+    const core = bridge();
+    if (core)
+        core.strict = on;
+}
+/** Whether runtime strict checks are on. */
+function isStrictEnabled() {
+    const flag = bridge()?.strict;
+    return flag === undefined ? globalThis.__SYGNAL_STRICT__ === true : flag === true;
+}
+/** The strict check's runtime half is SYG508 (replies.ts); this entry keeps the flag. */
+const strictCheck = {
+    id: 'strict',
+};
+
+// PLAN-4 GS-9: uid (the view's uid(name?) function)
+// (R5: 6.0 passes no `peers`, D164: a prop of that name reaches the view)
+const RESERVED$1 = ['children', 'slots', 'context', 'uid'];
+const propsCheck = {
+    id: 'props',
+    onRender(component) {
+        const props = component && component.currentProps;
+        if (!props || typeof props !== 'object')
+            return;
+        const name = nameOf(component);
+        const severity = isStrictEnabled() ? 'error' : 'warn';
+        for (const key of RESERVED$1) {
+            if (!(key in props) || !once(`SYG106:${name}:${key}`))
+                continue;
+            report('SYG106', {
+                component,
+                severity,
+                message: `The prop '${key}' passed to ${name} is overwritten: '${key}' is a reserved view argument, so the child never sees the parent's value`,
+                fix: `Rename the prop (for example '${key}Value'), in the parent and in ${name}`,
+                data: { prop: key },
+            });
+        }
+        if ('state' in props) {
+            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`)) {
+                report('SYG106', {
+                    component,
+                    severity,
+                    message: `The prop 'state' passed to ${name} is not data: Sygnal reads it as the child's state lens (a state field name or a { get, set } object), and the view's 'state' argument is the child's own state`,
+                    fix: `To give ${name} a slice of the parent state use state="fieldName"; to pass data, use another prop name (for example 'item')`,
+                    data: { prop: 'state', valueType: typeof value },
+                });
+            }
+        }
+    },
+};
+
+const describe$1 = (v) => v === null ? 'null' : v === undefined ? 'undefined' : Array.isArray(v) ? 'an array' : typeof v === 'object' ? 'an object' : `a ${typeof v}`;
+function checkCollection(component, el) {
+    const props = (el && el.data && el.data.props) || {};
+    const from = props.from;
+    const of = props.of;
+    const ofName = typeof of === 'function' ? (of.componentName || of.label || of.name || 'component') : String(of);
+    const name = nameOf(component);
+    let state = component.currentState;
+    try {
+        if (typeof component.addCalculated === 'function')
+            state = component.addCalculated(state);
+    }
+    catch (_) { }
+    let problem;
+    let fix = `Pass the name of an array field in ${name}'s state, e.g. <Collection of={${ofName}} from="items" />, and initialize that field to [] in initialState`;
+    // Every defined `from` (string field, lens object, or an invalid value) is reported by
+    // the core itself (SYG401/SYG412, retrofitted in 1E) in every diagnostics mode (D22), so
+    // this check only covers a missing `from`.
+    if (from !== undefined)
+        return;
+    if (!Array.isArray(state) && !(state && Array.isArray(state.value))) {
+        problem = `has no 'from' prop, so it uses ${name}'s whole state, which is ${describe$1(state)}, not an array`;
+    }
+    if (!problem || !once(`SYG401:${name}:undefined`))
+        return;
+    reportSafely('SYG401', {
+        component,
+        message: `<Collection of={${ofName}}> ${problem}, so it renders no items`,
+        fix,
+        data: { from: 'undefined', of: ofName },
+    });
+}
+const WRAPPED = '__sygnalDiagWrapped';
+const collectionsCheck = {
+    id: 'collections',
+    onModel(component) {
+        const original = component && component.instantiateCollection;
+        if (typeof original !== 'function' || original[WRAPPED])
+            return;
+        const wrapped = function (el, ...rest) {
+            try {
+                checkCollection(this, el);
+            }
+            catch (_) { }
+            return original.call(this, el, ...rest);
+        };
+        wrapped[WRAPPED] = true;
+        component.instantiateCollection = wrapped;
+    },
+};
+
+function isEqualNamespace(a, b) {
+    if (!Array.isArray(a) || !Array.isArray(b) || a.length !== b.length) {
+        return false;
+    }
+    for (let i = 0; i < a.length; i++) {
+        if (a[i].type !== b[i].type || a[i].scope !== b[i].scope) {
+            return false;
+        }
+    }
+    return true;
+}
+
+class ScopeChecker {
+    constructor(namespace, isolateModule) {
+        this.namespace = namespace;
+        this.isolateModule = isolateModule;
+        this._namespace = namespace.filter(n => n.type !== 'selector');
+    }
+    isDirectlyInScope(leaf) {
+        const namespace = this.isolateModule.getNamespace(leaf);
+        if (!namespace) {
+            return false;
+        }
+        if (this._namespace.length > namespace.length ||
+            !isEqualNamespace(this._namespace, namespace.slice(0, this._namespace.length))) {
+            return false;
+        }
+        for (let i = this._namespace.length; i < namespace.length; i++) {
+            if (namespace[i].type === 'total') {
+                return false;
+            }
+        }
+        return true;
+    }
+}
+
+/** the key of a control, from its selector `[data-control="<Key>"]` */
+const controlKey = (control) => String(control).slice(15, -2);
+/** a control selector `[data-control="<Key>"]` as its key, else undefined */
+const keyOfSelector = (selector) => {
+    const m = /^\[data-control="([^"]+)"\]$/.exec(selector);
+    return m ? m[1] : undefined;
+};
+const isControl$1 = (x) => typeof x == 'function' && !!x.__sygnalControl;
+const componentName = (fn) => fn.componentName || fn.label || fn.name || 'the component';
+let vnodeControls = new WeakMap();
+let staticsSeen = new WeakSet();
+onReset(() => {
+    vnodeControls = new WeakMap();
+    staticsSeen = new WeakSet();
+});
+/** the control that rendered a vnode (only while the dev entry is installed) */
+const controlOfVnode = (vnode) => vnode && typeof vnode == 'object' ? vnodeControls.get(vnode) : undefined;
+const STATICS$1 = ['intent', 'model', 'initialState'];
+const describe = (v) => v === undefined || v === null ? String(v)
+    : Array.isArray(v) ? `an array of ${v.length}`
+        : typeof v != 'object' ? `a ${typeof v} (${JSON.stringify(v)})`
+            : typeof v.sel != 'string' ? (v.text !== undefined ? 'a text vnode' : 'a fragment')
+                // the pragma's component placeholder (the component function in data.c)
+                : v.data && typeof v.data.c == 'function' ? `the component <${v.sel}>`
+                    : 'an element vnode';
+function onControl(control, vnode) {
+    const key = controlKey(control);
+    if (vnode && typeof vnode == 'object')
+        vnodeControls.set(vnode, control);
+    if (!staticsSeen.has(control)) {
+        staticsSeen.add(control);
+        const given = STATICS$1.filter(s => control[s] != null);
+        if (given.length) {
+            devReport('SYG125', {
+                message: `The control ${key} has ${given.map(s => '.' + s).join(', ')}, but controls are elements, not components: ${given.length > 1 ? 'these statics are' : 'it is'} never used`,
+                fix: `Put the intent and model on the component that renders <${key}>, and listen to the control in its intent: DOM.click(${key}). For something with its own state and actions, write a component instead`,
+                data: { control: key, statics: given },
+            });
+        }
+    }
+    const what = describe(vnode);
+    if (what == 'an element vnode')
+        return;
+    const kind = control.kind;
+    // report() (not devReport): in 'error' mode its DiagnosticError is thrown into the render
+    const d = report('SYG125', {
+        severity: DEV_CODE_SEVERITY.SYG125,
+        message: `The control ${key}'s spec${kind ? ` (kind '${kind}')` : ''} vnode() returned ${what}, but it must return one element vnode`,
+        fix: `Return a single element built with the h argument: vnode(props, children, h) { return h('div', props, ...children) }`,
+        data: { control: key, kind, returned: what },
+    });
+    if (d)
+        throw new Error(d.text);
+}
+/** Publish the control hook on the core bridge. Returns an uninstall function. */
+function installControlHooks() {
+    const core = bridge();
+    if (!core)
+        return () => { };
+    core.control = onControl;
+    return () => { if (core.control === onControl)
+        core.control = undefined; };
+}
+const wrapped$1 = new WeakMap();
+/** a DOM source whose select() and event shorthands report SYG124 for a component argument */
+function checkedDOM$1(component, dom) {
+    if (!dom || typeof dom != 'object')
+        return dom;
+    let proxy = wrapped$1.get(dom);
+    if (proxy)
+        return proxy;
+    proxy = new Proxy(dom, {
+        get(t, k) {
+            const v = t[k];
+            if (typeof k != 'string' || typeof v != 'function' || (k != 'select' && k in t))
+                return v;
+            return function (arg, ...rest) {
+                if (typeof arg == 'function' && !isControl$1(arg)) {
+                    const name = nameOf(component), child = componentName(arg);
+                    if (once(`SYG124:${name}:${child}:${k}`)) {
+                        const call = k == 'select' ? `DOM.select(${child})` : `DOM.${k}(${child})`;
+                        devReport('SYG124', {
+                            component,
+                            message: `${name}.intent passes the component ${child} to ${call}, but a component is not an element: it has no element of its own to listen on, and its elements are isolated from ${name}`,
+                            fix: `Handle the event in ${child} and send it up with PARENT, then read it here with CHILD.select(${child}); or render a control ${name} owns around it: const { ${child}Box } = controls({ ${child}Box: 'div' }), <${child}Box><${child} /></${child}Box>, DOM.click(${child}Box)`,
+                            data: { component: child, method: k },
+                        });
+                    }
+                }
+                const out = v.call(t, arg, ...rest);
+                return k == 'select' ? checkedDOM$1(component, out) : out;
+            };
+        },
+    });
+    wrapped$1.set(dom, proxy);
+    return proxy;
+}
+const controlsCheck = {
+    id: 'controls',
+    sources(component, sources) {
+        if (!sources || typeof Proxy != 'function')
+            return;
+        const domName = component?.DOMSourceName || 'DOM';
+        if (!sources[domName])
+            return;
+        return new Proxy(sources, {
+            get(t, k) {
+                const v = t[k];
+                return k === domName ? checkedDOM$1(component, v) : v;
+            },
+        });
+    },
+};
+
+const scopesOf = (ns) => ns.filter(s => s.type !== 'selector');
+const keyOf$1 = (scopes) => scopes.map(s => `${s.type[0]}:${s.scope}`).join('/');
+let pending = [];
+let tracked = new WeakMap();
+/** isolation-scope key -> the component instance that owns it (latest wins) */
+let owners = new Map();
+const ownerKeys = new WeakMap();
+let matched = new Set();
+let viewTokens = new WeakMap();
+onReset(() => {
+    pending = [];
+    tracked = new WeakMap();
+    owners = new Map();
+    matched = new Set();
+});
+const unref = (t) => { if (t && typeof t.unref === 'function')
+    t.unref(); return t; };
+function viewSource(component) {
+    const view = component && component.view;
+    if (typeof view !== 'function')
+        return '';
+    let src = viewTokens.get(view);
+    if (src === undefined) {
+        try {
+            src = Function.prototype.toString.call(view);
+        }
+        catch (_) {
+            src = '';
+        }
+        viewTokens.set(view, src);
+    }
+    return src;
+}
+/** class / id / tag tokens of a selector: '.a .b-c > #d' -> ['a', 'b-c', 'd'] */
+const tokensOf = (selector) => (selector.replace(/\[[^\]]*\]|:[\w-]+(\([^)]*\))?/g, ' ').match(/[A-Za-z_][\w-]*/g) || [])
+    // CT-1: a control's key (`<Add>` / `h(Add)` in the view source)
+    .concat(Array.from(selector.matchAll(/\[data-control="([^"]+)"\]/g), m => m[1]));
+function appearsInView(component, selector) {
+    const src = viewSource(component);
+    if (!src)
+        return false;
+    const tokens = tokensOf(selector);
+    if (!tokens.length)
+        return false;
+    return tokens.every(t => new RegExp(`(^|[^\\w-])${t.replace(/[-]/g, '\\-')}($|[^\\w-])`).test(src));
+}
+// G-144: a fragment-rooted component has several root elements
+function rootElementsOf(t) {
+    try {
+        const im = t.source._isolateModule;
+        return (im && im.getElements(scopesOf(t.source.namespace))) || [];
+    }
+    catch (_) {
+        return [];
+    }
+}
+function childNameFor(t, elements) {
+    const im = t.source._isolateModule;
+    const depth = scopesOf(t.source.namespace).length;
+    for (const el of elements) {
+        let ns;
+        try {
+            ns = im.getNamespace(el);
+        }
+        catch (_) {
+            ns = undefined;
+        }
+        if (!ns)
+            continue;
+        for (let i = depth; i < ns.length; i++) {
+            if (ns[i].type !== 'total')
+                continue;
+            const owner = owners.get(keyOf$1(ns.slice(0, i + 1)));
+            if (owner)
+                return nameOf(owner);
+            break;
+        }
+    }
+    return undefined;
+}
+function report103(component, t, selector, severity) {
+    if (!once(`SYG103:${severity}:${t.name}:${selector}`))
+        return;
+    reportSafely('SYG103', {
+        component,
+        severity,
+        message: `DOM.select('${selector}') in ${t.name} has not matched any element ${t.name} rendered` +
+            (severity === 'warn' ? ` (after ${t.renders} renders)` : ''),
+        fix: `Check the selector against the view's className/id. If the element is rendered by a child component, handle the event inside that child`,
+        data: { selector, renders: t.renders },
+    });
+}
+function sweep(component, t, escalate) {
+    if (t.disposed)
+        return;
+    const roots = rootElementsOf(t).filter(r => typeof r.querySelectorAll === 'function');
+    if (!roots.length)
+        return;
+    const im = t.source._isolateModule;
+    const checker = new ScopeChecker(t.source.namespace, im);
+    let unmatched = false;
+    for (const selector of t.selectors) {
+        const matchKey = `${t.name}\u0000${selector}`;
+        if (matched.has(matchKey) || t.crossed.has(selector))
+            continue;
+        let all;
+        try {
+            all = [];
+            for (const root of roots) {
+                all.push(...Array.prototype.slice.call(root.querySelectorAll(selector)));
+                if (root.matches(selector))
+                    all.push(root);
+            }
+        }
+        catch (_) {
+            continue; // invalid selector: the DOM driver reports that itself
+        }
+        const own = all.filter(el => { try {
+            return checker.isDirectlyInScope(el);
+        }
+        catch (_) {
+            return false;
+        } });
+        if (own.length) {
+            matched.add(matchKey);
+            continue;
+        }
+        if (all.length) {
+            t.crossed.add(selector);
+            if (!once(`SYG104:${t.name}:${selector}`))
+                continue;
+            const child = childNameFor(t, all) || 'a child component';
+            // CT-1: a control is named by its identifier
+            const control = keyOfSelector(selector);
+            reportSafely('SYG104', {
+                component,
+                message: `${control ? `The control ${control}` : `DOM.select('${selector}')`} in ${t.name} matches elements inside ${child} (isolated), so ${t.name} never receives their events`,
+                fix: `Handle the event in ${child}${control ? ` (DOM.<event>(${control}) in its intent)` : ''} and send it up with PARENT (read it here with CHILD.select(${child})), or use EVENTS`,
+                data: control ? { selector, child, control } : { selector, child },
+            });
+            continue;
+        }
+        if (appearsInView(component, selector))
+            continue;
+        unmatched = true;
+        if (escalate && t.renders >= timing.minRenders)
+            report103(component, t, selector, 'warn');
+        else
+            report103(component, t, selector, 'info');
+    }
+    if (unmatched && !escalate) {
+        clearTimeout(t.idleTimer);
+        t.idleTimer = unref(setTimeout(() => { t.idleTimer = undefined; sweep(component, t, true); }, timing.idleMs));
+    }
+}
+/**
+ * inspect (2B, read-only): a component's intent selectors on a real DOM source
+ * and whether a sweep has seen them match (true), only match inside a child
+ * (crossed), or neither yet. undefined when the component isn't tracked.
+ */
+function selectorStatus(component) {
+    const t = tracked.get(component);
+    return t && t.selectors.map(selector => ({
+        selector,
+        matched: matched.has(`${t.name}\u0000${selector}`) ? true : t.crossed.has(selector) ? false : null,
+        crossed: t.crossed.has(selector),
+    }));
+}
+const domCheck = {
+    id: 'dom',
+    onSelector(source, selector) {
+        const ns = source && source.namespace;
+        if (!Array.isArray(ns) || typeof selector !== 'string' || !selector)
+            return;
+        const prefix = ns.filter(s => s.type === 'selector').map(s => s.scope).join(' ');
+        pending.push({ key: keyOf$1(scopesOf(ns)), selector: prefix ? `${prefix} ${selector}` : selector });
+        if (pending.length > 1000)
+            pending.shift();
+    },
+    onIntent(component) {
+        const claimed = pending;
+        pending = [];
+        const source = component && component.sources && component.sources[component.DOMSourceName || 'DOM'];
+        if (!source || !source._isolateModule || !Array.isArray(source.namespace))
+            return;
+        const key = keyOf$1(scopesOf(source.namespace));
+        const name = nameOf(component);
+        owners.set(key, component);
+        ownerKeys.set(component, key);
+        const selectors = [...new Set(claimed.filter(p => p.key === key).map(p => p.selector))];
+        if (selectors.length)
+            tracked.set(component, { name, source, selectors, renders: 0, crossed: new Set() });
+    },
+    onRender(component) {
+        const t = tracked.get(component);
+        if (!t || t.disposed)
+            return;
+        t.renders++;
+        clearTimeout(t.idleTimer);
+        t.idleTimer = undefined;
+        if (t.settleTimer)
+            return;
+        t.settleTimer = unref(setTimeout(() => {
+            t.settleTimer = undefined;
+            sweep(component, t, false);
+        }, timing.settleMs));
+    },
+    onDispose(component) {
+        const key = ownerKeys.get(component);
+        if (key !== undefined && owners.get(key) === component)
+            owners.delete(key);
+        const t = tracked.get(component);
+        if (!t)
+            return;
+        t.disposed = true;
+        clearTimeout(t.settleTimer);
+        clearTimeout(t.idleTimer);
+        tracked.delete(component);
+    },
+};
+
+// Standard DOM / UI event names (lower case). In a browser, `on<name>` on an element or the
+// window also counts, so newer events are accepted there too.
+const KNOWN = new Set(('abort afterprint animationcancel animationend animationiteration animationstart auxclick ' +
+    'beforeinput beforeprint beforetoggle beforeunload blur cancel canplay canplaythrough change click close ' +
+    'compositionend compositionstart compositionupdate contextlost contextmenu contextrestored copy cuechange cut ' +
+    'dblclick drag dragend dragenter dragleave dragover dragstart drop durationchange emptied ended error ' +
+    'focus focusin focusout formdata fullscreenchange fullscreenerror gotpointercapture hashchange input invalid ' +
+    'keydown keypress keyup languagechange load loadeddata loadedmetadata loadstart lostpointercapture message ' +
+    'messageerror mousedown mouseenter mouseleave mousemove mouseout mouseover mouseup offline online pagehide ' +
+    'pageshow paste pause play playing pointercancel pointerdown pointerenter pointerleave pointermove pointerout ' +
+    'pointerover pointerrawupdate pointerup popstate progress ratechange rejectionhandled reset resize scroll ' +
+    'scrollend search securitypolicyviolation seeked seeking select selectionchange selectstart slotchange stalled ' +
+    'storage submit suspend timeupdate toggle touchcancel touchend touchmove touchstart transitioncancel ' +
+    'transitionend transitionrun transitionstart unhandledrejection unload visibilitychange volumechange waiting wheel').split(' '));
+const isKnown = (name) => {
+    // PLAN-5 0-S6: a hyphenated name is a custom element's event (DOM['wa-hover']('.food')): no
+    // standard DOM event has a hyphen, and a bracketed name is no typo for one
+    if (KNOWN.has(name) || name.includes('-'))
+        return true;
+    const on = 'on' + name;
+    const g = globalThis;
+    try {
+        return !!((g.HTMLElement && on in g.HTMLElement.prototype) || (g.window && on in g.window) ||
+            (g.Document && on in g.Document.prototype));
+    }
+    catch (_) {
+        return false;
+    }
+};
+// Names agents reach for that are enriched-stream methods or key names, not events
+const KEY_FIX = (sel, key) => `Listen for the real event and read the key: DOM.keydown(${sel}).key()` +
+    (key ? `.filter(k => k === '${key}')` : '');
+const SPECIAL = {
+    key: sel => KEY_FIX(sel),
+    keys: sel => KEY_FIX(sel),
+    enter: sel => KEY_FIX(sel, 'Enter'),
+    escape: sel => KEY_FIX(sel, 'Escape'),
+    esc: sel => KEY_FIX(sel, 'Escape'),
+    value: sel => `Listen for the real event and read the value: DOM.input(${sel}).value()`,
+    checked: sel => `Listen for the real event and read the box: DOM.change(${sel}).checked()`,
+    data: sel => `Listen for the real event and read the attribute: DOM.click(${sel}).data('name')`,
+    doubleclick: sel => `Use DOM.dblclick(${sel})`,
+};
+const fixFor = (name, selector) => {
+    const sel = typeof selector === 'string' ? `'${selector}'` : 'sel';
+    const special = SPECIAL[name.toLowerCase()];
+    if (special)
+        return special(sel);
+    const s = suggest(name, KNOWN);
+    return (s ? `Did you mean DOM.${s}(${sel})? ` : '') +
+        `If '${name}' is a custom event you dispatch yourself, use the explicit form DOM.select(${sel}).events('${name}')`;
+};
+const wrapped = new WeakMap();
+function checkedDOM(component, dom) {
+    if (!dom || typeof dom != 'object')
+        return dom;
+    let proxy = wrapped.get(dom);
+    if (proxy)
+        return proxy;
+    const name = nameOf(component);
+    proxy = new Proxy(dom, {
+        get(t, k) {
+            const v = t[k];
+            if (typeof k != 'string' || k in t || typeof v != 'function' || isKnown(k))
+                return v;
+            return function (selector, ...rest) {
+                if (once(`SYG115:${name}:${k}`)) {
+                    devReport('SYG115', {
+                        component,
+                        message: `${name}.intent uses DOM.${k}(${typeof selector == 'string' ? `'${selector}'` : '…'}), but '${k}' is not a DOM event, so it never fires`,
+                        fix: fixFor(k, selector),
+                        data: { event: k, selector },
+                    });
+                }
+                return v.call(this, selector, ...rest);
+            };
+        },
+    });
+    wrapped.set(dom, proxy);
+    return proxy;
+}
+const shorthandCheck = {
+    id: 'shorthand',
+    sources(component, sources) {
+        if (!sources || typeof Proxy != 'function')
+            return;
+        const domName = component?.DOMSourceName || 'DOM';
+        if (!sources[domName])
+            return;
+        return new Proxy(sources, {
+            get(t, k) {
+                const v = t[k];
+                return k === domName ? checkedDOM(component, v) : v;
+            },
+        });
+    },
+};
+
+/** The element commands Sygnal documents and types (the core runs any method of the element) */
+const NATIVE_COMMAND_NAMES = ['focus', 'blur', 'select', 'click', 'scrollIntoView', 'showModal', 'show', 'close', 'showPopover', 'hidePopover', 'togglePopover'];
+const core = () => globalThis.__SYGNAL_DIAGNOSTICS__;
+const send = (code, details) => {
+    try {
+        core()?.report(code, { severity: DEV_CODE_SEVERITY[code], ...details });
+    }
+    catch (err) {
+        // 'error' mode: rethrown asynchronously (never into the caller)
+        setTimeout(() => { throw err; });
+    }
+};
+const isControl = (x) => typeof x == 'function' && !!x.__sygnalControl;
+const keyOf = (control) => String(control).slice(15, -2);
+/** a command as written: `{ focus: Email, preventScroll: true }` */
+const describeCommand = (cmd) => {
+    if (!cmd || typeof cmd != 'object')
+        return JSON.stringify(cmd) ?? String(cmd);
+    const parts = Object.keys(cmd).map(k => {
+        const v = cmd[k];
+        let text;
+        if (isControl(v))
+            text = keyOf(v);
+        else
+            try {
+                text = JSON.stringify(v) ?? String(v);
+            }
+            catch (_) {
+                text = String(v);
+            }
+        return `${k}: ${text}`;
+    });
+    return `{ ${parts.join(', ')} }`;
+};
+const distance = (a, b) => {
+    const row = Array.from({ length: b.length + 1 }, (_, i) => i);
+    for (let i = 1; i <= a.length; i++) {
+        let prev = row[0];
+        row[0] = i;
+        for (let j = 1; j <= b.length; j++) {
+            const cur = row[j];
+            row[j] = Math.min(row[j] + 1, row[j - 1] + 1, prev + (a[i - 1] == b[j - 1] ? 0 : 1));
+            prev = cur;
+        }
+    }
+    return row[b.length];
+};
+const closest = (name, names) => {
+    let best, d = 3;
+    for (const n of names) {
+        const x = n.toLowerCase() == name.toLowerCase() ? 0 : distance(name, n);
+        if (x < d) {
+            d = x;
+            best = n;
+        }
+    }
+    return best;
+};
+const tagOf = (el) => el && typeof el.tagName == 'string' ? `<${el.tagName.toLowerCase()}>` : 'element';
+const notACommand = (component, name, cmd) => send('SYG641', {
+    component,
+    message: `${name} sent ${describeCommand(cmd)} to the ELEMENT sink, which is not a command`,
+    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) {
+    // a disposed instance's pending commands are dropped silently
+    if (component && component._disposed)
+        return;
+    const name = (component && component.name) || 'component';
+    const method = cmd && typeof cmd == 'object' ? Object.keys(cmd)[0] : undefined;
+    if (method === undefined)
+        return notACommand(component, name, cmd);
+    const target = cmd[method];
+    const what = `ELEMENT ${describeCommand(cmd)}`;
+    const control = isControl(target) ? keyOf(target) : undefined;
+    const data = { method, command: cmd, ...(control ? { control } : { selector: target == null ? target : String(target) }) };
+    if (!el) {
+        const missing = target == null || 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`,
+            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,
+        });
+    }
+    // PLAN-5 W-1: the matched element is a widget's host (selector or control target): SYG142 names
+    // the widget's declared commands
+    const widget = el.__sw?.w;
+    if (widget) {
+        const declared = Object.keys(widget.commands);
+        const hint = closest(method, [...declared, ...NATIVE_COMMAND_NAMES]);
+        return send('SYG142', {
+            component,
+            message: `${what} in ${name}: the matched ${tagOf(el)} is a widget's host, and the widget declares no '${method}' command` +
+                (hint ? ` (did you mean '${hint}'?)` : '') + (declared.length ? `; it declares: ${declared.join(', ')}` : '; it declares none'),
+            fix: `Add '${method}' to the widget's commands (defineWidget({ commands: { ${method}: (instance, options) => … } })), or send one it declares`,
+            data: { ...data, element: tagOf(el), commands: declared },
+        });
+    }
+    const commands = control && target.spec && typeof target.spec == 'object' && target.spec.commands
+        ? Object.keys(target.spec.commands) : [];
+    data.element = tagOf(el);
+    if (commands.length)
+        data.commands = commands;
+    let message, fix;
+    if (NATIVE_COMMAND_NAMES.includes(method)) {
+        message = `${what} in ${name}: the matched ${tagOf(el)} has no ${method}() method${commands.length ? `, and the control ${control}'s spec declares no '${method}' command (it declares: ${commands.join(', ')})` : ''}`;
+        fix = /^(show|showModal|close)$/.test(method)
+            ? `${method}() works on a <dialog> element: render the target as a <dialog>`
+            : /Popover$/.test(method)
+                ? `The popover methods need an element with the popover attribute (attrs: { popover: 'auto' }) in a browser with the Popover API`
+                : `Target an element that has ${method}()`;
+    }
+    else {
+        const hint = closest(method, [...commands, ...NATIVE_COMMAND_NAMES]);
+        message = `${what} in ${name}: '${method}' is not an element command` + (hint ? ` (did you mean '${hint}'?)` : '') +
+            (el.tagName ? `: the matched ${tagOf(el)} has no such method` : '') +
+            (commands.length ? `, and the control ${control}'s spec declares only: ${commands.join(', ')}` : '');
+        fix = `Use ${commands.length ? `one of its commands (${commands.join(', ')}) or ` : ''}one of: ${NATIVE_COMMAND_NAMES.join(', ')} (or another method of the element, like play). The first key of a command is the method, the others are its options: { scrollIntoView: Row, block: 'nearest' }`;
+    }
+    send('SYG641', { component, message, fix, data });
+}
+// methods that change the DOM snabbdom owns (the next patch undoes them or trips over them)
+const DOM_MUTATORS = /^(remove|append|prepend|before|after|replaceWith|replaceChildren|appendChild|removeChild|insertBefore|replaceChild|insertAdjacent(Element|HTML|Text)|(set|remove|toggle)Attribute(NS|Node)?|attachShadow|setHTML(Unsafe)?|normalize)$/;
+/** SYG641 when it is sent: not a command object, or a method that changes the DOM Sygnal renders */
+function checkSentCommand(component, cmd) {
+    if (cmd == null)
+        return;
+    const name = (component && component.name) || 'component';
+    if (typeof cmd != 'object' || Array.isArray(cmd) || !Object.keys(cmd).length)
+        return notACommand(component, name, cmd);
+    const method = Object.keys(cmd)[0], target = cmd[method];
+    if (!DOM_MUTATORS.test(method) || (isControl(target) && target.spec?.commands?.[method]))
+        return;
+    send('SYG641', {
+        component,
+        message: `ELEMENT ${describeCommand(cmd)} in ${name}: ${method}() changes the DOM that ${name}'s view renders, so the next render undoes it or fails`,
+        fix: `Change the state and render the result instead; element commands are for what a view can't express (focus, scrolling, dialogs, popovers, media)`,
+        data: { method, command: cmd },
+    });
+}
+/** The dev entry check: checkSentCommand runs on every ELEMENT value through the core's onElementCommand hook (checks/next.ts) */
+const elementCommandsCheck = {
+    id: 'elementCommands',
+};
+/** Publish the element command hook on the core bridge. Returns an uninstall function. */
+function installElementCommandHooks() {
+    const c = core();
+    if (!c)
+        return () => { };
+    c.elementCommand = reportElementCommand;
+    return () => { if (c.elementCommand === reportElementCommand)
+        c.elementCommand = undefined; };
+}
+
+/**
+ * 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).
+ */
+/** a widget's name for messages: `name` from its definition, else its host tag */
+const widgetName = (w) => w?.def?.name ? `widget ${w.def.name}` : `widget <${w?.def?.tag || 'div'}>`;
+const ids = new WeakMap();
+let next = 0;
+const idOf = (w) => {
+    let id = ids.get(w);
+    if (id === undefined)
+        ids.set(w, id = ++next);
+    return id;
+};
+const PHASE = { 660: 'mount', 661: 'update', 662: 'unmount' };
+function reportWidget(code, w, owner, x, reported) {
+    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) => `'${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) => 'on' + e in x);
+        if (!native.length)
+            return;
+        return devReport('SYG144', {
+            component: name,
+            message: `${name} declares ${native.map((e) => `'${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. */
+function installWidgetHooks() {
+    const c = globalThis.__SYGNAL_DIAGNOSTICS__;
+    if (!c)
+        return () => { };
+    c.widget = reportWidget;
+    return () => { if (c.widget === reportWidget)
+        c.widget = undefined; };
+}
+
+/**
+ * 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)
+ */
+const tag = (owner) => `<VirtualCollection> in ${nameOf(owner)}`;
+function reportVirtual(code, owner, x = {}) {
+    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. */
+function installVirtualHooks() {
+    const c = globalThis.__SYGNAL_DIAGNOSTICS__;
+    if (!c)
+        return () => { };
+    c.virtual = reportVirtual;
+    return () => { if (c.virtual === reportVirtual)
+        c.virtual = undefined; };
+}
+
+const what$1 = (v) => v === null || v === undefined ? String(v)
+    : typeof v == 'function' ? 'a function (a defineBehavior factory not called?)'
+        : typeof v == 'object' ? 'a plain object'
+            : `a ${typeof v}`;
+const behaviorsCheck = {
+    id: 'behaviors',
+    onModel(component) {
+        const view = component?.view, uses = view?.uses;
+        if (!uses || typeof uses != 'object' || !once('SYG127:' + nameOf(component)))
+            return;
+        const init = view.initialState;
+        for (const key of Object.keys(uses)) {
+            const b = uses[key];
+            if (typeof b?.merge != 'function') {
+                devReport('SYG127', {
+                    component,
+                    message: `uses entry '${key}' is ${what$1(b)}, not a defineBehavior() result; it was skipped, so state.${key} and its '${key}.*' actions don't exist`,
+                    fix: `Use a defineBehavior() factory's result: uses = { ${key}: behavior(options) }`,
+                    data: { key, reason: 'unresolvable' },
+                });
+            }
+            else if (init && typeof init == 'object' && key in init) {
+                devReport('SYG127', {
+                    component,
+                    message: `uses key '${key}' is also a key of ${nameOf(component)}'s initialState; the behavior's slice replaces that value`,
+                    fix: `Remove '${key}' from initialState (pass its values as the behavior's options), or rename the uses key`,
+                    data: { key, reason: 'initialState' },
+                });
+            }
+        }
+    },
+};
+
+const isRow = (r) => r?.id != null;
+// the key of segment `s` in `v`: an array's row with that id, else the index unless the element
+// there is a row (G-380: a row is named by its id only; -1, no element), an object's key
+const key = (v, s) => {
+    if (!Array.isArray(v))
+        return s;
+    const i = v.findIndex(r => isRow(r) && r.id + '' == s);
+    return i < 0 && !isRow(v[+s]) ? +s : i;
+};
+/** whether `name` is a field of `values`: its path exists (G-379: also when the value is undefined) */
+const hasField = (values, name) => {
+    let v = values;
+    for (const s of name.split('.')) {
+        const k = v && typeof v == 'object' ? key(v, s) : -1;
+        if (!(k in Object(v)))
+            return false;
+        v = v[k];
+    }
+    return true;
+};
+
+// the form's own action names (G-577: read from the form's model, so CHECKED_<field> counts)
+const ownActions = (b) => Object.keys(b?.model || {});
+const SUBMIT_FIX = (key, a, own) => `Name the submit after a host action the form doesn't define (not ${own.join(', ')}): submit: 'SAVE', and rename the model entry '${a}' to SAVE: { HTTP: (state, values) => ({ url, json: values, ok: '${key}.DONE', error: '${key}.ERRORS' }) }`;
+const RESERVED = ['ok', 'error', 'latest'];
+const what = (v) => v === null || v === undefined ? String(v)
+    : typeof v == 'function' ? 'a function'
+        : Array.isArray(v) ? 'an array'
+            : typeof v == 'object' ? `an object without ~standard.validate${typeof v.parse == 'function' ? ' (a validator from before Standard Schema?)' : ''}`
+                : `a ${typeof v}`;
+function reportForm(code, a, b, c) {
+    if (code == 231) {
+        const err = new TypeError(`[Sygnal SYG231] form(schema, options): the schema is ${what(a)}, not a Standard Schema. ` +
+            `Pass a Standard Schema object: a zod, valibot or arktype schema, or an object with '~standard': { version: 1, vendor, validate }. ${docsUrlFor('SYG231')}`);
+        err.code = 'SYG231';
+        throw err;
+    }
+    if (code == 230) {
+        if (!once(`SYG230:${a}`))
+            return;
+        devReport('SYG230', {
+            component: 'form',
+            message: `form: a field named '${a}' changed, but '${a}' isn't a field of the form's values (${Object.keys(b || {}).join(', ') || 'none'}); the change is ignored`,
+            fix: `Name the input after a path in values (name="email", name="addresses.<row id>.city"), add '${a}' to values, or move the input out of the form element`,
+            data: { name: a },
+        });
+    }
+    else if (code == 232) {
+        devReport('SYG232', {
+            component: 'form',
+            message: `form: a submit was dropped: ${a?.submitting ? 'the previous submit is still being sent (no form.DONE / form.ERRORS yet)' : 'a submit is already queued, waiting for an async check or an async schema'}`,
+            fix: `Disable the submit button while state.form.submitting (or queued) is true; answer the submit with ok: 'form.DONE', error: 'form.ERRORS'`,
+        });
+    }
+    else if (code == 233) {
+        if (!b || typeof b != 'object' || Object.keys(b).some(k => !(k in (a || {}))))
+            return;
+        for (const k of Object.keys(a || {})) {
+            if (!(k in b) && once(`SYG233:${k}`))
+                devReport('SYG233', {
+                    component: 'form',
+                    message: `form: values.${k} is not in the schema's output (stripped or renamed), so the submit action doesn't get it under that name (a schema strips keys it doesn't declare)`,
+                    fix: `Declare '${k}' in the schema (or make the schema keep unknown keys), or remove it from values; if the schema renames it on purpose, ignore this`,
+                    data: { key: k },
+                });
+        }
+    }
+    else if (code == 234) {
+        if (!once(`SYG234:run:${b}:${a}`))
+            return;
+        devReport('SYG234', {
+            component: 'form',
+            message: `form '${b}': a valid submit dispatched '${b}.${a}' (the form's own ${a} action), not the host's '${a}': submit: '${a}' names one of the form's own actions, which next() prefers`,
+            fix: SUBMIT_FIX(b, a, ownActions(c)),
+            data: { key: b, submit: a },
+        });
+    }
+    else if (code == 235) {
+        const set = RESERVED.filter(k => b && k in b);
+        if (set.length && once(`SYG235:req:${a}`))
+            devReport('SYG235', {
+                component: 'form',
+                message: `form: the check for '${a}' returns a request with ${set.map(k => `'${k}'`).join(', ')}; the form sets them itself (its reply action and latest: true), so they are replaced`,
+                fix: `Return only the request: check: { ${a}: { request: (v) => ({ url, query }), error: (body) => message } }`,
+                data: { field: a, keys: set },
+            });
+    }
+}
+/** row ids missing in `values`: the names of the arrays of objects that have a row without an id */
+const missingIds = (v, at = '', out = []) => {
+    if (v && typeof v == 'object') {
+        if (Array.isArray(v) && v.some(r => r && typeof r == 'object' && !Array.isArray(r) && r.id == null))
+            out.push(at);
+        for (const k in v)
+            missingIds(v[k], at ? `${at}.${k}` : k, out);
+    }
+    return out;
+};
+const formsCheck = {
+    id: 'forms',
+    onModel(component) {
+        const view = component?.view, uses = view?.uses;
+        if (!uses || typeof uses != 'object')
+            return;
+        const name = nameOf(component), sels = {};
+        for (const key of Object.keys(uses)) {
+            const b = uses[key];
+            if (!b?.form)
+                continue;
+            // G-374: each form listens on its selector inside the host, so two with one selector hear
+            // each other's fields and submits
+            const sel = b.options?.form || 'form';
+            if (sel in sels) {
+                if (once(`SYG237:${name}:${sel}`))
+                    devReport('SYG237', {
+                        component,
+                        message: `${name}'s forms '${sels[sel]}' and '${key}' both listen on '${sel}', so each hears the other's fields and submits`,
+                        fix: `Give each form element its own class and pass it: ${sels[sel]}: form(schema, { ..., form: '.${sels[sel]}' }), ${key}: form(schema, { ..., form: '.${key}' })`,
+                        data: { keys: [sels[sel], key], form: sel },
+                    });
+            }
+            else
+                sels[sel] = key;
+            if (!once(`SYG23x:${name}:${key}`))
+                continue;
+            const o = b.options || {}, values = o.values || {};
+            const model = Object.keys(view.model || {}).map(a => a.split('|')[0].trim()), own = ownActions(b);
+            const clash = own.includes(o.submit);
+            if (typeof o.submit != 'string' || !model.includes(o.submit) || clash) {
+                devReport('SYG234', {
+                    component,
+                    message: typeof o.submit != 'string' ? `${name}'s form '${key}' has no submit action, so a valid submit dispatches nothing`
+                        : clash ? `${name}'s form '${key}' names submit: '${o.submit}', one of the form's own actions; a valid submit dispatches the form's '${key}.${o.submit}'${model.includes(o.submit) ? `, never ${name}'s '${o.submit}' entry` : ''}`
+                            : `${name}'s form '${key}' dispatches '${o.submit}' on a valid submit, but ${name} has no model entry '${o.submit}'`,
+                    fix: clash ? SUBMIT_FIX(key, o.submit, own)
+                        : `Name a host action and add it to the model: submit: 'SIGN_UP', model: { SIGN_UP: { HTTP: (state, values) => ({ url, json: values, ok: '${key}.DONE', error: '${key}.ERRORS' }) } }`,
+                    data: { key, submit: o.submit },
+                });
+            }
+            for (const f of Object.keys(o.check || {})) {
+                if (!hasField(values, f))
+                    devReport('SYG235', {
+                        component,
+                        message: `${name}'s form '${key}' has a check for '${f}', which isn't a field of its values; it never runs`,
+                        fix: `Use a field name from values (${Object.keys(values).join(', ')})`,
+                        data: { key, field: f },
+                    });
+            }
+            for (const at of missingIds(values))
+                devReport('SYG236', {
+                    component,
+                    message: `${name}'s form '${key}': values.${at} has rows without an id, so its fields are named by index and errors, touched state and focus don't follow a row when another is removed`,
+                    fix: `Give each row a unique id: ${at}: [{ id: 1, ... }] (form.ADD numbers new rows itself)`,
+                    data: { key, field: at },
+                });
+        }
+    },
+};
+/** Install the `form` hook on the core bridge (form.ts calls it). */
+function installFormHooks() {
+    const c = globalThis.__SYGNAL_DIAGNOSTICS__;
+    if (!c)
+        return () => { };
+    c.form = reportForm;
+    return () => { if (c.form === reportForm)
+        c.form = undefined; };
+}
+
+/**
+ * PLAN-5 B-1 (3-D): `sortable` behavior diagnostics (dev entry; src/extra/sortable.ts carries no
+ * text). The behavior calls `__SYGNAL_DIAGNOSTICS__.sortable(code, ...args)`:
+ *   145  (item element, item selector, attr) a press or key on an item whose element has no
+ *        `attr`: SYG145 (warn, once per selector); the event is ignored
+ *   146  (host root, item, handle, attr) the host's first pointerdown / keydown: SYG146 (warn,
+ *        once per selector) when elements carry `attr` under the root but none matches `item`,
+ *        or items exist but none contains `handle`. Returns true once it could decide (an empty
+ *        list can't tell: the check runs again at the next interaction)
+ *   147  (from key, host state, uses key) when the host starts: a `from` key whose value isn't
+ *        an array: SYG147 (warn, once per key)
+ *   435  (3-H G-449) (fn, uses key, from keys, idOf): the host's own items' ids as shown, per
+ *        container (fn() returns [the item elements, the root]; the behavior only asks in dev), or nothing when
+ *        every list has been reported (3-L G-478: no scan). A row's place is its `data-index`
+ *        when it has one (VirtualCollection's pinned focused row is out of DOM order). (shown
+ *        groups, host state, from keys, idField, uses key) at a keyboard pick-up or a pointer
+ *        press: SYG435 (warn, once per uses key and list) when a list's shown items (those in
+ *        the container holding most of them: an element elsewhere with a matching id is no list
+ *        item; a row's container is its nearest ancestor holding another row, 3-O G-505) aren't
+ *        one run of the array in its order (a Collection's sort, or a filter hiding entries
+ *        between shown ones)
+ */
+const all = (root, sel) => {
+    try {
+        return [...root.querySelectorAll(sel)];
+    }
+    catch (_) {
+        return [];
+    }
+};
+function reportSortable(code, a, b, c, d, e) {
+    if (code == 145) {
+        if (once(`SYG145:${b}:${c}`))
+            devReport('SYG145', {
+                component: 'sortable',
+                message: `sortable: an item ('${b}') has no ${c} attribute, so it can't be moved (the behavior finds each item in the list by that id)`,
+                fix: `Render the item's id on its element: <li className="${String(b).replace(/^\./, '')}" ${c}={item.id}>, or name the attribute: sortable({ ..., attr: 'data-key' })`,
+                data: { item: b, attr: c },
+            });
+        return;
+    }
+    if (code == 146) {
+        const root = a, item = b, handle = c, attr = d;
+        if (!root?.querySelectorAll)
+            return true;
+        const items = all(root, item).filter(el => el !== root);
+        if (!items.length) {
+            // nothing carries the id attribute either: an empty list (decide later)
+            if (!all(root, `[${attr}]`).length)
+                return false;
+            report146('item', item, `no element under the host matches it, though elements with ${attr} are rendered`, `Use the selector of the items' elements (the element with ${attr}), e.g. item: '.task'`);
+            return true;
+        }
+        if (handle && !items.some(el => all(el, handle).length)) {
+            report146('handle', handle, `no item ('${item}') contains an element that matches it`, `Use the selector of the drag handle inside each item, e.g. handle: '.grip', or leave handle out to drag the whole item`);
+        }
+        return true;
+    }
+    if (code == 435) {
+        // (fn, uses key, from keys, idOf) the shown ids per container: computed only here (dev)
+        if (typeof a == 'function') {
+            if ((c || []).every((l) => onced(`SYG435:${b}:${l}`)))
+                return;
+            try {
+                const by = new Map(), [els, root] = a(), n = new Map();
+                // a row's place: its data-index (a VirtualCollection row below the host's root; its
+                // pinned row isn't in DOM order)
+                const rows = els.map((el) => {
+                    const r0 = el.closest?.('[data-index]'), row = r0 && r0 !== root && root.contains?.(r0) ? r0 : el;
+                    return [el, row, Number(row === el && !r0 ? NaN : row.getAttribute('data-index'))];
+                });
+                // 3-O G-505: a row's container is its nearest ancestor holding another row (items each in
+                // their own wrapper, <li><div data-id>, a table cell, a Collection item's root, are still
+                // one list); `n` counts the rows below each ancestor
+                const up = (row, f) => { for (let p = row.parentElement; p; p = p === root ? null : p.parentElement)
+                    if (f(p))
+                        return p; };
+                for (const [, row] of rows)
+                    up(row, p => void n.set(p, (n.get(p) || 0) + 1));
+                for (const [el, row, at] of rows) {
+                    const p = up(row, p => n.get(p) > 1) || row.parentElement;
+                    by.has(p) || by.set(p, []);
+                    by.get(p).push([isNaN(at) ? by.get(p).length : at, String(d(el))]);
+                }
+                return [...by.values()].map(g => g.sort((x, y) => x[0] - y[0]).map(x => x[1]));
+            }
+            catch (_) {
+                return;
+            }
+        }
+        // (shown groups, host state, from keys, idField, uses key) at a keyboard pick-up or a press
+        const groups = Array.isArray(a?.[0]) ? a : [a || []];
+        for (const l of c || []) {
+            if (onced(`SYG435:${e}:${l}`))
+                continue;
+            const at = new Map();
+            if (Array.isArray(b?.[l]))
+                b[l].forEach((x, i) => at.set(String(x?.[d]), i));
+            // the list's container: the one holding most of its entries (others: stray matches)
+            let dom = [];
+            for (const g of groups) {
+                const ix = g.filter(i => at.has(i)).map(i => at.get(i));
+                if (ix.length > dom.length)
+                    dom = ix;
+            }
+            // a contiguous run in the array's order is fine (all of it, or a window of it)
+            if (!dom.some((v, j) => v !== dom[0] + j))
+                continue;
+            if (once(`SYG435:${e}:${l}`))
+                devReport('SYG435', {
+                    component: 'sortable',
+                    message: `sortable '${e}': state.${l} is shown ${dom.length < at.size ? 'with entries hidden between the shown ones' : 'in another order'} (a Collection with ${dom.length < at.size ? 'filter' : 'sort'}?), but moves and the announced positions follow the array: a keyboard step can pass entries nobody sees, or change nothing visible`,
+                    fix: `Reorder a list that is shown as it is stored: drop the Collection's sort (sort state.${l} itself), and hide the drag handles while a filter hides entries`,
+                    data: { from: l, key: e },
+                });
+        }
+        return;
+    }
+    if (code == 147) {
+        const st = b || {}, arrays = Object.keys(st).filter(k => Array.isArray(st[k]));
+        const near = suggest(a, arrays);
+        if (once(`SYG147:${c}:${a}`))
+            devReport('SYG147', {
+                component: 'sortable',
+                message: `sortable '${c}': from names '${a}', but state.${a} is ${st[a] === undefined ? 'missing' : 'not an array'} when the host starts${near ? ` (did you mean '${near}'?)` : ''}; nothing in it can be moved`,
+                fix: `Name the host state's list: sortable({ from: '${near || arrays[0] || 'items'}', ... })${arrays.length ? ` (arrays in the state: ${arrays.join(', ')})` : `, and start it as an array (initialState: { ${a}: [] })`}`,
+                data: { from: a, key: c },
+            });
+    }
+}
+const report146 = (option, selector, why, fix) => {
+    if (once(`SYG146:${option}:${selector}`))
+        devReport('SYG146', {
+            component: 'sortable',
+            message: `sortable: ${option} '${selector}' matches nothing: ${why}, so no item can be dragged`,
+            fix,
+            data: { option, selector },
+        });
+};
+/** Install the `sortable` hook on the core bridge (sortable.ts calls it). */
+function installSortableHooks() {
+    const c = globalThis.__SYGNAL_DIAGNOSTICS__;
+    if (!c)
+        return () => { };
+    c.sortable = reportSortable;
+    return () => { if (c.sortable === reportSortable)
+        c.sortable = undefined; };
+}
+
+const camel = (key) => key.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
+const BAD_CHAR = /[\s"'<>\/=`]/;
+function problem(key) {
+    if (/-[a-z]/.test(key))
+        return `has a hyphen followed by a lower-case letter, which a dataset name can't have`;
+    if (BAD_CHAR.test(key))
+        return `contains a character an HTML attribute name can't have`;
+    return undefined;
+}
+function walk(vnode, visit, depth = 0) {
+    if (!vnode || typeof vnode != 'object' || depth > 500)
+        return;
+    const ds = vnode.data && vnode.data.dataset;
+    if (ds && typeof ds == 'object')
+        visit(ds, vnode.sel);
+    const children = vnode.children;
+    if (Array.isArray(children))
+        for (const c of children)
+            walk(c, visit, depth + 1);
+}
+const datasetCheck = {
+    id: 'dataset',
+    onRender(component, rootVnode) {
+        walk(rootVnode, (dataset, sel) => {
+            for (const key of Object.keys(dataset)) {
+                const why = problem(key);
+                if (!why || !once(`SYG421:${key}`))
+                    continue;
+                const good = camel(key).replace(new RegExp(BAD_CHAR.source, 'g'), '');
+                const attr = good.replace(/[A-Z]/g, c => '-' + c.toLowerCase());
+                const name = good || 'name';
+                devReport('SYG421', {
+                    component,
+                    message: `The view of ${nameOf(component)} renders the data key '${key}'${sel ? ` on <${String(sel).split(/[.#]/)[0]}>` : ''} ` +
+                        `(from data={{ '${key}': … }}), but '${key}' ${why}. ` +
+                        `Writing it throws a DOMException, which can stop rendering`,
+                    fix: `Use a camelCase key in the data prop: data={{ ${name}: … }} renders the attribute data-${attr || 'name'}; read it with .data('${name}')`,
+                    data: { key, suggested: good, attribute: `data-${attr}` },
+                });
+            }
+        });
+    },
+};
+
+const REPLY_KEYS = ['ok', 'error'];
+// PLAN-3 5-4b: on the router's sink, `{ route }` (the route static) and `{ block }` name reply actions
+const ROUTER_KEYS = ['route', 'block'];
+const CONNECTION_KEYS = ['message', 'open', 'close', 'error'];
+/** [action, key, connection name?] for every reply action name a sink value names */
+function replyNames(req, router) {
+    const out = [];
+    for (const key of router ? REPLY_KEYS.concat(ROUTER_KEYS) : REPLY_KEYS)
+        if (typeof req[key] === 'string')
+            out.push([req[key], key]);
+    const conns = req.connections;
+    if (conns && typeof conns === 'object') {
+        for (const name of Object.keys(conns)) {
+            const spec = conns[name];
+            if (!spec || typeof spec !== 'object')
+                continue;
+            for (const key of CONNECTION_KEYS)
+                if (typeof spec[key] === 'string')
+                    out.push([spec[key], key, name]);
+            const events = spec.events;
+            if (events && typeof events === 'object') {
+                for (const ev of Object.keys(events))
+                    if (typeof events[ev] === 'string')
+                        out.push([events[ev], `events.${ev}`, name]);
+            }
+        }
+    }
+    return out;
+}
+/** instance → 'SINK\0category' → the select/errors call that read it */
+const selected = new WeakMap();
+function readingSource(component, sink, source) {
+    const wrapped = Object.create(source);
+    for (const method of ['select', 'errors']) {
+        if (typeof source[method] !== 'function')
+            continue;
+        wrapped[method] = (category, ...rest) => {
+            if (typeof category === 'string') {
+                let reads = selected.get(component);
+                if (!reads)
+                    selected.set(component, reads = new Map());
+                reads.set(`${sink}\0${category}`, `${sink}.${method}('${category}')`);
+            }
+            return source[method](category, ...rest);
+        };
+    }
+    return wrapped;
+}
+function checkRequest(component, sink, req, modelActions) {
+    if (!req || typeof req !== 'object')
+        return;
+    const name = nameOf(component);
+    let replies = false;
+    for (const [action, key, connection] of replyNames(req, !!component?.sources?.[sink]?.__sygnalRouter)) {
+        replies = true;
+        let seen = replySeen.get(component);
+        if (!seen)
+            replySeen.set(component, seen = new Set());
+        seen.add(action);
+        if (modelActions.includes(action) || !once(`SYG112:${name}:${action}`))
+            continue;
+        const near = 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 },
+        });
+    }
+    // SYG508 (strict): a request without reply actions whose replies this instance reads back with select()/errors()
+    if (replies || 'abort' in req || typeof req.category !== 'string' || !isStrictEnabled())
+        return;
+    const read = selected.get(component)?.get(`${sink}\0${req.category}`);
+    if (!read || !once(`SYG508:${name}:${sink}:${req.category}`))
+        return;
+    // (inside a sink stream: reportSafely, so 'error' mode can't break the stream)
+    reportSafely('SYG508', {
+        severity: STRICT_CODE_SEVERITY.SYG508,
+        component,
+        message: `${name} sends a ${sink} request with category: '${req.category}' and reads the reply back with ${read}`,
+        fix: `Use reply actions instead: name them in the request, ${sink}: (state) => ({ url, ok: 'LOADED', error: 'FAILED' }), ` +
+            `handle LOADED (the parsed body) and FAILED ({ error, status, body, request }) in the model, and remove ${read} from the intent`,
+        data: { sink, category: req.category, read },
+    });
+}
+const repliesCheck = {
+    id: 'replies',
+    sources(component, sources) {
+        if (!isStrictEnabled() || typeof Proxy != 'function')
+            return;
+        const cache = new Map();
+        return new Proxy(sources, {
+            get(t, k) {
+                const v = t[k];
+                if (typeof k != 'string' || !v || v.__sygnalReplies !== true)
+                    return v;
+                if (!cache.has(k))
+                    cache.set(k, readingSource(component, k, v));
+                return cache.get(k);
+            },
+        });
+    },
+};
+
+const PARAM = /:(\w+)/g;
+const paramsOf = (pat) => (pat.match(PARAM) || []).map(p => p.slice(1));
+function checkHref(routes, name, params) {
+    const names = Object.keys(routes).filter(k => routes[k] != '*');
+    const pat = routes[name];
+    if (pat == null || pat == '*') {
+        if (!once(`SYG130:${name}`))
+            return;
+        const near = suggest(String(name), names);
+        devReport('SYG130', {
+            message: `href('${name}') names no route, so the link points to '/'` + (near ? ` (did you mean '${near}'?)` : ''),
+            fix: `Use one of the route names: ${names.join(', ')}`,
+            data: { name, routes: names, ...(near ? { suggestion: near } : {}) },
+        });
+        return;
+    }
+    const wanted = paramsOf(pat);
+    const given = params && typeof params == 'object' ? params : {};
+    const missing = wanted.filter(k => given[k] == null);
+    const extra = Object.keys(given).filter(k => !wanted.includes(k));
+    if (missing.length && once(`SYG130:${name}:${missing}`)) {
+        devReport('SYG130', {
+            message: `href('${name}') leaves out ${missing.map(k => `'${k}'`).join(', ')} (${pat}), so that segment is empty`,
+            fix: `href('${name}', { ${wanted.join(', ')} })`,
+            data: { name, pattern: pat, missing },
+        });
+    }
+    if (extra.length && once(`SYG131:${name}:${extra}`)) {
+        devReport('SYG131', {
+            message: `Route '${name}' (${pat}) has no param ${extra.map(k => `'${k}'`).join(', ')}; it is ignored`,
+            fix: wanted.length ? `Pass only ${wanted.join(', ')}; put other values in the query: href('${name}', params, { ${extra[0]} })` : `Put it in the query: href('${name}', {}, { ${extra[0]} })`,
+            data: { name, pattern: pat, extra },
+        });
+    }
+}
+/** install the hook the router's href() calls (removed by the returned function) */
+function installRouterHooks() {
+    const core = bridge();
+    if (!core)
+        return () => { };
+    core.routerHref = checkHref;
+    return () => { if (core.routerHref === checkHref)
+        core.routerHref = undefined; };
+}
+const routerCheck = {
+    id: 'router',
+    onModel(component) {
+        const sources = component?.sources;
+        if (!sources || typeof sources != 'object')
+            return;
+        const name = nameOf(component);
+        for (const n of component.sourceNames || Object.keys(sources)) {
+            const src = sources[n];
+            const k = src?.__sygnalStatic;
+            if (typeof k == 'string' && component.view?.[k] != null) {
+                // statics are computed from state (G-167: with or without a model): a root whose state
+                // never emits (a model but no initialState) never sends one
+                if (!component.isSubComponent && component.initialState === undefined && once(`SYG132:${name}:${k}`)) {
+                    devReport('SYG132', {
+                        component,
+                        message: `${name} declares ${name}.${k}, but a root without initialState has no state, so ${k} is never sent to ${n}`,
+                        fix: `Add ${name}.initialState (e.g. { }${k == 'route' ? ', or { route: router.current() }' : ''})`,
+                        data: { static: k, source: n, reason: 'state' },
+                    });
+                }
+            }
+            const opts = src?.__sygnalRouter;
+            const g = globalThis;
+            if (opts && typeof opts == 'object' && !opts.navigate && g.document?.getElementById?.('vike_pageContext') && once('SYG133')) {
+                devReport('SYG133', {
+                    component,
+                    message: `The SPA router (${n}) runs inside a Vike app: Vike owns links and history, so both would handle a click`,
+                    fix: "Pass Vike's navigate: makeRouter({ routes, navigate }) with import { navigate } from 'vike/client/router', or use Vike's routing",
+                    data: { source: n },
+                });
+            }
+        }
+    },
+};
+
+/*
+ * Standard Schema (https://standardschema.dev) without a dependency: any validator that exposes
+ * `schema['~standard'].validate(value)` (zod, valibot, arktype, ...), sync or async.
+ * Used by makeFetchDriver's `validate` (PLAN-3 §1.6, D80); PLAN-4's forms and server functions
+ * reuse it.
+ */
+/** true for a Standard Schema object (it has `~standard.validate`) */
+const isStandardSchema = (schema) => !!schema && (typeof schema == 'object' || typeof schema == 'function') && typeof schema['~standard']?.validate == 'function';
+
+const IDEMPOTENT = /^(GET|HEAD)$/i;
+/** instance → reply key lanes it has sent, and ok name → the other key it was sent under */
+const lanes = new WeakMap();
+const fetchSink = (component, name) => component?.sources?.[name]?.__sygnalStatic === 'resources';
+/** 5-5: the sink's driver has no queryCache() */
+const noCache = (component, sink) => {
+    const i = component?.sources?.[sink]?.__inspect?.();
+    return !!i && i.cache === undefined;
+};
+const reportNoCache = (component, sink, what, url) => {
+    if (!noCache(component, sink) || !once(`SYG635:${nameOf(component)}:${what}:${url}`))
+        return;
+    devReport('SYG635', {
+        component,
+        message: `${sink} ${url ? url + ' ' : ''}uses ${what}, but the ${sink} driver has no queryCache(), so nothing is cached`,
+        fix: `Give the driver a cache: makeFetchDriver({ cache: queryCache({ staleTime: 30000 }) }) (import { queryCache } from 'sygnal'); in tests renderComponent(C, { http: { cache: queryCache() } }). Or remove ${what}`,
+        data: { sink, url, what },
+    });
+};
+function checkOne(component, sink, req, where) {
+    if (!req || typeof req !== 'object')
+        return;
+    const name = nameOf(component);
+    const url = typeof req.url === 'string' ? req.url : '';
+    const method = String(req.method || (req.json !== undefined || req.body !== undefined ? 'POST' : 'GET')).toUpperCase();
+    if ((req.cache === true || req.staleTime != null) && !IDEMPOTENT.test(method) && once(`SYG630:${name}:${method}:${url}`)) {
+        devReport('SYG630', {
+            component,
+            message: `${where} ${method} ${url} sets ${req.cache === true ? 'cache: true' : 'staleTime'}, so a cached reply answers it instead of sending it again`,
+            fix: `Cache reads only: remove ${req.cache === true ? 'cache' : 'staleTime'} from the ${method}, and refresh the cached reads after it succeeds with invalidates: ['tag']`,
+            data: { sink, method, url },
+        });
+    }
+    if (req.cache === true || req.staleTime != null)
+        reportNoCache(component, sink, req.cache === true ? 'cache: true' : 'staleTime', url);
+    if ('validate' in req && !isStandardSchema(req.validate) && once(`SYG631:${name}:${url}`)) {
+        devReport('SYG631', {
+            component,
+            message: `${where} ${url} has validate: ${typeof req.validate}, which is not a Standard Schema, so the request fails`,
+            fix: "Pass a Standard Schema object (zod, valibot, arktype, ...: anything with a '~standard'.validate function), e.g. validate: QuoteSchema",
+            data: { sink, url },
+        });
+    }
+}
+function check(component, sink, req) {
+    if (!req || typeof req !== 'object')
+        return;
+    const name = nameOf(component);
+    const res = req.resources;
+    if (res && typeof res === 'object') {
+        for (const k of Object.keys(res))
+            checkOne(component, sink, typeof res[k] === 'string' ? { url: res[k] } : res[k], `${name}.resources.${k}:`);
+        return;
+    }
+    if (req.prefetch) {
+        const p = req.prefetch;
+        reportNoCache(component, sink, '{ prefetch }', typeof p === 'string' ? p : String(p?.url ?? ''));
+        return;
+    }
+    if ('invalidate' in req) {
+        const count = component.sources[sink]?.__matches?.(req.invalidate);
+        const what = typeof req.invalidate === 'function' ? 'the predicate' : JSON.stringify(req.invalidate);
+        if (count === 0 && once(`SYG632:${name}:${what}`)) {
+            devReport('SYG632', {
+                component,
+                message: `${sink} { invalidate: ${what} } matched no cache entry and no mounted resource`,
+                fix: "Give the resources (or cached requests) to refresh tags: ['quotes'] and invalidate that tag, or a URL prefix starting with '/' ('/api/quotes')",
+                data: { sink, invalidate: what },
+            });
+        }
+        return;
+    }
+    let l = lanes.get(component);
+    if (!l)
+        lanes.set(component, (l = { used: new Set(), keyed: new Map() }));
+    const { ok, error, key, abort } = req;
+    if (typeof abort === 'string' && key === undefined) {
+        const other = l.keyed.get(abort);
+        if (other !== undefined && !l.used.has(abort) && once(`SYG633:${name}:${abort}`)) {
+            devReport('SYG633', {
+                component,
+                message: `${sink} { abort: '${abort}' } cancels the requests with key '${abort}', but ${name} sends its ok: '${abort}' requests with key: '${other}', so nothing is cancelled`,
+                fix: `Cancel by that key: { abort: true, key: '${other}' } (or drop the key, so the lane is the ok action)`,
+                data: { sink, abort, key: other },
+            });
+        }
+        return;
+    }
+    if (typeof ok === 'string' || typeof error === 'string') {
+        const lane = key ?? ok ?? error;
+        l.used.add(lane);
+        if (typeof ok === 'string' && key !== undefined && key !== ok)
+            l.keyed.set(ok, String(key));
+    }
+    checkOne(component, sink, req, `A ${sink} request`);
+}
+const fetchCheck = {
+    id: 'fetch',
+    onModel(component) {
+        const model$ = component?.model$;
+        if (!model$ || typeof model$ !== 'object')
+            return;
+        for (const sink of Object.keys(model$)) {
+            const s$ = model$[sink];
+            if (!fetchSink(component, sink) || !s$ || typeof s$.map !== 'function')
+                continue;
+            model$[sink] = s$.map((req) => {
+                try {
+                    check(component, sink, req);
+                }
+                catch (_) { }
+                return req;
+            });
+        }
+    },
+};
+
+const NEEDS = {
+    timers: 'makeTimerDriver()',
+    connections: 'makeSocketDriver()',
+    resources: 'makeFetchDriver()',
+    browser: 'makeBrowserDriver()',
+};
+const KEY = { timers: 'TIMER', connections: 'WS', resources: 'HTTP', browser: 'BROWSER' };
+const brief$1 = (v) => { try {
+    return JSON.stringify(v);
+}
+catch (_) {
+    return String(v);
+} };
+/** why a timer spec can't run ('' when it can; mirrors timers.ts's valid()) */
+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 (!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$1(s.every)})`;
+    return s.after >= 0 && s.after < 1 / 0 ? '' : `after must be a number of ms, 0 or more (got ${brief$1(s.after)})`;
+}
+function checkSpec(name, spec, component) {
+    const problem = timerSpecProblem(spec) || 'is invalid';
+    if (!once(`SYG422:${component}:${name}:${brief$1(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) */
+function installTimerHooks() {
+    const core = bridge();
+    if (!core)
+        return () => { };
+    core.timerSpec = checkSpec;
+    return () => { if (core.timerSpec === checkSpec)
+        core.timerSpec = undefined; };
+}
+const timersCheck = {
+    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) => 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] },
+            });
+        }
+    },
+};
+
+/**
+ * Browser sources (PLAN-5 B-3, src/extra/browserSources.ts). Dev-entry-only codes
+ * (DEV_CODE_SEVERITY), reported when the driver calls
+ * `__SYGNAL_DIAGNOSTICS__.browserSource(code, name, spec, componentName, extra)`:
+ *
+ * SYG663 — a `browser` entry the driver can't start (no known kind, no `action`, an intersection
+ *          / resize target that is neither a selector nor `true`), or a BROWSER sink command
+ *          with an unknown method. It isn't started / run.
+ * SYG664 — a kind the driver wasn't made with (`makeBrowserDriverWith(...)` without its source).
+ * SYG665 — a source or command failed (permission denied, API missing, storage blocked) and its
+ *          spec names no `error` action, so nothing else would say so.
+ * SYG668 — an intersection / resize declaration with nothing to observe: no DOM source reached
+ *          the driver for the instance (extra 'dom'), or, in renderComponent's fake with
+ *          `dom: 'real'`, its selector matches no element of the component (extra 'none').
+ *
+ * A component declaring `browser` with no browser driver is SYG643 (checks/timers.ts).
+ */
+const KINDS = ['intersection', 'resize', 'media', 'storage', 'visibility', 'online', 'geolocation'];
+const SOURCE = {
+    intersection: 'intersectionSource', resize: 'resizeSource', media: 'mediaSource', storage: 'storageSource',
+    visibility: 'visibilitySource', online: 'onlineSource', geolocation: 'geolocationSource',
+    copy: 'clipboardSource', paste: 'clipboardSource', setItem: 'storageSource', removeItem: 'storageSource',
+};
+const brief = (v) => { try {
+    return JSON.stringify(v);
+}
+catch (_) {
+    return String(v);
+} };
+/** why a declared spec can't start ('' when it can; mirrors browserDriver's checks) */
+function browserSpecProblem(s) {
+    if (!s || typeof s != 'object')
+        return `is not an object ({ ${KINDS.join(' | ')}: …, action })`;
+    const k = KINDS.find(k => k in s);
+    if (!k)
+        return `names no source (one of ${KINDS.join(', ')})`;
+    if (!s.action || typeof s.action != 'string')
+        return 'has no action (a string)';
+    if ((k == 'intersection' || k == 'resize') && s[k] !== true && (typeof s[k] != 'string' || !s[k]))
+        return `${k} must be a selector in the component or true (its root element), got ${brief(s[k])}`;
+    return '';
+}
+function onBrowserSource(code, name, spec, component, extra, commands) {
+    if (code == 'SYG663' && extra === 0) {
+        // an unknown command (extra 0; `commands`: the driver's)
+        if (!once(`SYG663:${component}:cmd:${name}`))
+            return;
+        devReport('SYG663', {
+            component,
+            message: `BROWSER command '${name}' is unknown; it is not run`,
+            fix: `Name the method as a key of the command: ${(commands || []).map(c => `{ ${c}: … }`).join(', ') || 'this driver takes no commands'}`,
+            data: { name, command: spec },
+        });
+        return;
+    }
+    if (code == 'SYG663') {
+        if (!once(`SYG663:${component}:${name}:${brief(spec)}`))
+            return;
+        devReport('SYG663', {
+            component,
+            message: `browser entry '${name}' ${browserSpecProblem(spec) || 'is invalid'}; it is not started`,
+            fix: `Declare ${name}: { media: '(prefers-color-scheme: dark)', action: 'DARK' }, { intersection: '.card', action: 'SEEN' }, … (falsy to stop it)`,
+            data: { name, spec },
+        });
+    }
+    else if (code == 'SYG664') {
+        if (!once(`SYG664:${component}:${name}`))
+            return;
+        devReport('SYG664', {
+            component,
+            message: `browser entry '${name}' uses the ${extra} source, which this browser driver wasn't made with; it is not started`,
+            fix: `Add it: makeBrowserDriverWith(${SOURCE[extra]}, …), or use makeBrowserDriver() (every source)`,
+            data: { name, spec, kind: extra },
+        });
+    }
+    else if (code == 'SYG668') {
+        if (!once(`SYG668:${component}:${name}:${extra}`))
+            return;
+        const k = KINDS.find(k => spec && k in spec) || 'intersection', target = spec?.[k];
+        devReport('SYG668', {
+            component,
+            message: extra == 'none'
+                ? `browser entry '${name}' observes ${brief(target)}, which matches no element of the component; it reports nothing`
+                : `browser entry '${name}' (${k}) has no DOM to observe: the component's DOM source didn't reach the browser driver; it reports nothing`,
+            fix: extra == 'none'
+                ? `Use a selector the component's own view renders (or true for its root element), and declare the entry only while that element exists`
+                : `Run the app with a DOM driver (run() with a mount point) and declare intersection / resize in a component's own \`browser\` static`,
+            data: { name, spec, reason: extra },
+        });
+    }
+    else if (code == 'SYG665') {
+        if (!once(`SYG665:${component}:${name}:${extra?.name ?? extra?.code}`))
+            return;
+        devReport('SYG665', {
+            component,
+            message: `browser ${spec && 'action' in spec ? `entry '${name}'` : `command '${name}'`} failed (${extra?.message || extra?.name || 'error'}) and names no error action`,
+            fix: `Name one to handle it, e.g. { ..., error: 'FAILED' }, and a model entry FAILED: (state, { message }) => ...`,
+            data: { name, spec, failure: extra },
+        });
+    }
+}
+/** install the hook the browser driver calls (removed by the returned function) */
+function installBrowserSourceHooks() {
+    const core = bridge();
+    if (!core)
+        return () => { };
+    core.browserSource = onBrowserSource;
+    return () => { if (core.browserSource === onBrowserSource)
+        core.browserSource = undefined; };
+}
+
+const persistCheck = {
+    id: 'persist',
+    onModel(component) {
+        const view = component?.view, p = view?.persist;
+        if (!p)
+            return;
+        const name = nameOf(component);
+        if (component.isSubComponent) {
+            // 3-B2: under Vike's Layout/Wrapper shell (onRenderClient's `__vike` source) the Page,
+            // Layouts and Wrappers are all sub-components of the shell root
+            const vike = component.sources?.__vike;
+            if (once('SYG224:' + name))
+                devReport('SYG224', {
+                    component,
+                    message: vike
+                        ? `${name}.persist is set, but ${name} renders in Vike's Layout/Wrapper shell (the shell is the app's root), so its state is never saved or restored: persist() isn't supported on Vike pages, layouts or wrappers yet`
+                        : `${name}.persist is set, but ${name} is not the root component, so its state is never saved or restored (persist() works on the root only)`,
+                    fix: vike
+                        ? `Remove persist from ${name}. Save the state yourself (STATE.watch writing to localStorage, read back in BOOTSTRAP), or use persist() on a component you run() yourself, or on a Vike page with no Layout or Wrapper (it is its own root)`
+                        : `Move persist to the root component (the one passed to run()) and pick the keys it holds: persist({ key, pick: ['${name.toLowerCase()}'] })`,
+                    data: { key: p.options?.key, ...(vike && { vike: true }) },
+                });
+            return;
+        }
+        const o = p.options, init = view.initialState;
+        if (!o || !init || typeof init != 'object')
+            return;
+        const keys = Object.keys(init);
+        for (const opt of ['pick', 'omit']) {
+            for (const k of Array.isArray(o[opt]) ? o[opt] : []) {
+                if (keys.includes(k) || !once(`SYG223:${name}:${opt}:${k}`))
+                    continue;
+                devReport('SYG223', {
+                    component,
+                    message: `persist ${opt} names '${k}', which is not a key of ${name}.initialState, so it is ${opt == 'pick' ? 'never saved' : 'never left out'}${didYouMean(k, keys)}`,
+                    fix: `Use top-level keys of initialState in ${opt} (${keys.join(', ')}), or add '${k}' to initialState`,
+                    data: { option: opt, key: k, stateKeys: keys },
+                });
+            }
+        }
+    },
+};
+
+const viewTransitionsCheck = {
+    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) => `'${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 },
+        });
+    },
+};
+
+/**
+ * PLAN-4.5 G-275: marks an initial state that a wrapper built from its caller's values (an
+ * element's host props, Vike's pageContext.data or hydrated state, renderComponent's
+ * initialState option). The dev statics freeze (D152, checks/statics.ts) leaves a marked object
+ * and everything in it alone: the caller may still change those values. A non-enumerable symbol
+ * key: spreads, JSON and Object.keys don't see it.
+ */
+const OWNED = Symbol.for('sygnal.owned');
+
+const plain = (v) => {
+    if (!v || typeof v != 'object')
+        return false;
+    const p = Object.getPrototypeOf(v);
+    return Array.isArray(v) || p === Object.prototype || p === null;
+};
+const deepFreeze = (v) => {
+    if (!plain(v) || Object.isFrozen(v) || v[OWNED])
+        return;
+    Object.freeze(v);
+    for (const k of Object.keys(v))
+        deepFreeze(v[k]);
+};
+const freeze = (o) => {
+    if (!o || (typeof o != 'object' && typeof o != 'function'))
+        return;
+    deepFreeze(o.initialState);
+    for (const k of ['model', 'context', 'calculated'])
+        if (plain(o[k]))
+            Object.freeze(o[k]);
+};
+const staticsCheck = {
+    id: 'statics',
+    onIntent(component) {
+        if (typeof component?.view == 'function')
+            freeze(component.view);
+        freeze(component?._o);
+    },
+};
+
+/**
+ * SYG301 — an RxJS operator was called on an xstream stream (error).
+ *
+ * Without help this fails with a bare "x.switchMap is not a function" inside
+ * the intent function. Mechanism: when 'sygnal/diagnostics' is loaded, every
+ * RxJS operator name below that xstream's Stream does NOT already have is
+ * defined on Stream.prototype (non-enumerable) as a method that throws an
+ * enriched TypeError: same "stream.<op> is not a function" shape, plus the
+ * xstream equivalent and the SYG301 docs link. The error is also reported
+ * (collected / printed per the diagnostics mode; in 'error' mode report()
+ * throws the DiagnosticError itself). It works anywhere a stream is used
+ * (intent, peers, drivers), with no hook in the core.
+ *
+ * Caveat: `typeof stream.pipe === 'function'` is true while this entry is
+ * loaded (dev only).
+ */
+/** RxJS operator -> xstream equivalent. */
+const RXJS_HINTS = {
+    pipe: `chain xstream operators directly (.map(...).filter(...)), or use .compose(operator) for extra operators`,
+    switchMap: `.map(x => inner$).flatten()`,
+    mergeMap: `.map(x => inner$).compose(flattenConcurrently) (import { flattenConcurrently } from 'sygnal')`,
+    flatMap: `.map(x => inner$).compose(flattenConcurrently) (import { flattenConcurrently } from 'sygnal')`,
+    concatMap: `.map(x => inner$).compose(flattenSequentially) (import { flattenSequentially } from 'sygnal')`,
+    exhaustMap: `.map(x => inner$).flatten() (xstream has no exhaustMap; ignore new values while busy with .filter())`,
+    switchAll: `.flatten()`,
+    mergeAll: `.compose(flattenConcurrently) (import { flattenConcurrently } from 'sygnal')`,
+    concatAll: `.compose(flattenSequentially) (import { flattenSequentially } from 'sygnal')`,
+    debounceTime: `.compose(debounce(ms)) (import { debounce } from 'sygnal')`,
+    debounce: `.compose(debounce(ms)) (import { debounce } from 'sygnal')`,
+    throttleTime: `.compose(throttle(ms)) (import { throttle } from 'sygnal')`,
+    throttle: `.compose(throttle(ms)) (import { throttle } from 'sygnal')`,
+    auditTime: `.compose(throttle(ms)) (import { throttle } from 'sygnal')`,
+    delay: `.compose(delay(ms)) (import { delay } from 'sygnal')`,
+    distinctUntilChanged: `.compose(dropRepeats()) (import { dropRepeats } from 'sygnal')`,
+    withLatestFrom: `.compose(sampleCombine(other$)) (import { sampleCombine } from 'sygnal')`,
+    combineLatest: `xs.combine(a$, b$) (import { xs } from 'sygnal')`,
+    combineLatestWith: `xs.combine(a$, b$) (import { xs } from 'sygnal')`,
+    merge: `xs.merge(a$, b$) (import { xs } from 'sygnal')`,
+    mergeWith: `xs.merge(a$, b$) (import { xs } from 'sygnal')`,
+    concat: `concat(a$, b$) (import { concat } from 'sygnal')`,
+    scan: `.fold((acc, x) => next, seed)`,
+    reduce: `.fold((acc, x) => next, seed).last()`,
+    skip: `.drop(n)`,
+    first: `.take(1)`,
+    takeUntil: `.endWhen(other$)`,
+    tap: `.debug(fn)`,
+    do: `.debug(fn)`,
+    catchError: `.replaceError(err => fallback$)`,
+    catch: `.replaceError(err => fallback$)`,
+    pluck: `.map(x => x.field)`,
+    share: `xstream streams are already shared (hot); use .remember() to replay the latest value`,
+    shareReplay: `.remember()`,
+    publishReplay: `.remember()`,
+    finalize: `.debug({ complete: fn }) or handle completion in the subscriber`,
+};
+const SYG301_URL = docsUrlFor('SYG301');
+function rxjsError(op) {
+    const hint = RXJS_HINTS[op];
+    const message = `stream.${op} is not a function: '${op}' is an RxJS operator, but Sygnal streams are xstream streams`;
+    const fix = `Use ${hint}`;
+    // In 'error' mode report() throws the DiagnosticError itself (we are about to throw anyway).
+    const d = report('SYG301', { message, fix, data: { operator: op, hint } });
+    const err = new TypeError(d ? d.text : `[Sygnal SYG301] ${message}. ${fix}. ${SYG301_URL}`);
+    err.diagnostic = d;
+    return err;
+}
+/** Install the hints on xstream's Stream.prototype. Returns an uninstall function. */
+function installRxjsHints(proto) {
+    const added = [];
+    if (!proto)
+        return () => { };
+    for (const op of Object.keys(RXJS_HINTS)) {
+        if (op in proto)
+            continue;
+        Object.defineProperty(proto, op, {
+            configurable: true,
+            writable: true,
+            enumerable: false,
+            value: function rxjsOperatorHint() { throw rxjsError(op); },
+        });
+        added.push(op);
+    }
+    return () => { for (const op of added)
+        delete proto[op]; };
+}
+
+/**
+ * PLAN-4 2-C (GS-10): the action log. Records every action a component instance runs as
+ *   { type, data, component, instance, sinks, cause, time }
+ * for renderComponent's t.actions / t.explain() (src/extra/testing.ts), inspect({ actions }) in
+ * the 'sygnal/diagnostics' dev entry (./inspect.ts) and the DevTools action log
+ * (src/extra/devtoolsActions.ts).
+ *
+ * 0 B in apps: nothing in the core calls this. actionHooks() is a hook layer of the core
+ * (04-hooks-contract §3.3): onAction opens the record (the core passes the cause: 'intent',
+ * 'next', 'reply', 'built-in', 'simulateAction'; an intent action a behavior owns is
+ * 'behavior'), wrapHandler sees which sinks produced a value. (The old core's version patched
+ * each instance; R5 removed it.)
+ *
+ * Sinks: a function reducer counts when it returns a value: not ABORT (or another symbol, which
+ * the core drops), and for STATE not the state it was given (GS-4: no change); EFFECT counts when
+ * the handler ran without ABORT. A constant / `true` entry always sends. A throwing reducer
+ * sends nothing.
+ */
+const BUILT_IN = /^(BOOTSTRAP|INITIALIZE|DISPOSE|RESOURCE)$/;
+/** now on the test's fake clock when there is one (vi.useFakeTimers()), else Date.now() */
+const clockNow = () => {
+    const c = setTimeout.clock;
+    return c ? c.now : Date.now();
+};
+/**
+ * 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
+ * owns is 'behavior'. `only(inst)`: the instances to record (renderComponent: its own tree).
+ */
+function actionHooks(listener, only) {
+    const cur = new WeakMap();
+    // INITIALIZE: the core writes the initial state at creation (no action, unless the model
+    // has an INITIALIZE entry); today's log has an INITIALIZE record with STATE, so it is opened here
+    const init = new WeakMap();
+    return {
+        onCreate(inst) {
+            const d = inst.def;
+            if ((only && !only(inst)) || d.initialState === undefined || !(inst.isRoot || d.isolated))
+                return;
+            const rec = { type: 'INITIALIZE', data: d.initialState, component: inst.name, instance: String(inst.id), sinks: [], cause: 'built-in', time: clockNow() };
+            init.set(inst, rec);
+            try {
+                listener.action(rec, inst);
+            }
+            catch (_) { /* ignore */ }
+            addSink(listener, rec, ['STATE'], 'STATE', undefined);
+        },
+        onAction(inst, a) {
+            if (only && !only(inst))
+                return;
+            const type = String(a.type), owned = inst.def.behaviorActions;
+            const hs = inst.def.handlers.get(type) || [], order = hs.map((h) => h[0]);
+            const opened = type == 'INITIALIZE' && init.get(inst);
+            if (opened) {
+                init.delete(inst);
+                cur.set(inst, [opened, order]);
+                return;
+            }
+            const cause = a.cause == 'simulateAction' ? a.cause : BUILT_IN.test(type) ? 'built-in'
+                : a.cause == 'next' || a.cause == 'reply' ? 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 }) };
+            cur.set(inst, [rec, order]);
+            try {
+                listener.action(rec, inst);
+            }
+            catch (_) { /* a listener never breaks the app */ }
+            // a constant / `true` entry always sends (EFFECT runs functions only)
+            for (const [sink, h] of hs)
+                if (typeof h != 'function' && sink != 'EFFECT')
+                    addSink(listener, rec, order, sink, undefined);
+        },
+        wrapHandler(inst, type, sink, fn) {
+            const c = cur.get(inst);
+            if (!c || c[0].type !== type || typeof fn != 'function')
+                return;
+            const [rec, order] = c, isState = sink == 'STATE', isEffect = sink == 'EFFECT';
+            return function (state) {
+                const r = fn.apply(this, arguments);
+                if (!isAbort(r) && (isEffect || typeof r != 'symbol') && !(isState && r === state))
+                    addSink(listener, rec, order, sink, fn[ORIGINAL] || fn);
+                return r;
+            };
+        },
+    };
+}
+function addSink(l, rec, order, sink, reducer) {
+    if (!rec.sinks.includes(sink)) {
+        rec.sinks.push(sink);
+        rec.sinks.sort((a, b) => order.indexOf(a) - order.indexOf(b));
+    }
+    try {
+        l.sink?.(rec, sink, reducer);
+    }
+    catch (_) { /* ignore */ }
+}
+
+let records = new Map();
+let pendingSelects = [];
+/** every EVENTS type seen on the bus */
+let busTypes = new Set();
+/** PLAN-4 2-C (GS-10): the most recent actions of any instance, oldest first */
+const RECENT_MAX = 200;
+let recent = [];
+let epoch = clockNow();
+const actionListener = {
+    action(r) { if (recent.push(r) > RECENT_MAX)
+        recent.shift(); },
+};
+onReset(() => {
+    records = new Map();
+    pendingSelects = [];
+    busTypes = new Set();
+    recent = [];
+    epoch = clockNow();
+});
+const uniq = (list) => [...new Set(list)];
+const NEXT_KIND = { root: 'root', child: 'child', item: 'collection-item', page: 'switchable' };
+function kindOf(c) {
+    // PLAN-4.6 R4: the core's instance view says it (checks/next.ts)
+    return (c && c.__next && NEXT_KIND[c.__next.kind]) || 'child';
+}
+function ensure(c) {
+    let r = records.get(c);
+    if (!r) {
+        const parent = c && c.__next && c.__next.parentId;
+        r = {
+            instance: c,
+            id: String(c && c._componentNumber),
+            name: nameOf(c),
+            parentId: typeof parent === 'number' ? String(parent) : null,
+            kind: kindOf(c),
+            intentActions: [],
+            injected: new Set(),
+            modelMap: {},
+            fired: new Set(),
+            eventsSelected: new Set(),
+            eventsEmitted: new Set(),
+            controls: new Map(),
+        };
+        records.set(c, r);
+    }
+    return r;
+}
+let devtools;
+function attachDevtools() {
+    const dt = globalThis.__SYGNAL_DEVTOOLS__;
+    if (!dt || typeof dt !== 'object')
+        return;
+    devtools = dt;
+    if (dt.inspect !== inspect) {
+        try {
+            dt.inspect = inspect;
+        }
+        catch (_) { /* frozen: ignore */ }
+    }
+}
+const inspectCheck = {
+    id: 'inspect',
+    onBusSelect(type) {
+        if (type === undefined || type === null || type === '')
+            pendingSelects.push('*');
+        else
+            for (const t of [].concat(type))
+                if (typeof t === 'string')
+                    pendingSelects.push(t);
+        if (pendingSelects.length > 1000)
+            pendingSelects.shift();
+    },
+    onIntent(component, actionNames) {
+        attachDevtools();
+        const r = ensure(component);
+        const intent$ = component && component.intent$;
+        r.intentActions = actionNames || [];
+        r.injected = new Set((intent$ && typeof intent$ === 'object' && intent$.__sygnalTestActions) || []);
+        for (const t of pendingSelects)
+            r.eventsSelected.add(t);
+        pendingSelects = [];
+    },
+    onModel(component, modelMap) {
+        const r = ensure(component);
+        r.modelMap = modelMap || {};
+    },
+    onRender(component, root) {
+        const r = records.get(component);
+        if (r)
+            collectControls(root, r.controls, true);
+    },
+    onReducer(component, action) {
+        const r = records.get(component);
+        if (r && typeof action === 'string')
+            r.fired.add(action);
+    },
+    onBusEmit(type) {
+        if (typeof type === 'string')
+            busTypes.add(type);
+    },
+    onDispose(component) {
+        records.delete(component);
+    },
+};
+/** PLAN-4.6 R4 (onSink): an EVENTS value the instance sent */
+function eventEmitted(component, ev) {
+    const r = records.get(component);
+    if (r && ev && typeof ev.type === 'string')
+        r.eventsEmitted.add(ev.type);
+}
+/**
+ * CT-1: record the controls in a component's rendered tree (data-control="<Key>"), stopping at
+ * isolated child components (their root carries data.isolate on the real DOM, a '.___<scope>'
+ * class in the mock DOM): the controls inside belong to the child.
+ */
+function collectControls(v, out, root) {
+    if (!v || typeof v != 'object')
+        return;
+    if (!root && typeof v.sel == 'string' && ((v.data && v.data.isolate) || v.sel.includes('.___')))
+        return;
+    const key = v.data && v.data.attrs && v.data.attrs['data-control'];
+    if (typeof key == 'string' && !out.has(key)) {
+        const control = controlOfVnode(v);
+        const spec = control && control.spec;
+        out.set(key, spec && typeof spec == 'object'
+            ? { element: null, kind: String(spec.kind) }
+            : { element: typeof spec == 'string' ? spec : typeof v.sel == 'string' ? v.sel.split(/[.#]/)[0] : null });
+    }
+    for (const k of [].concat(v.children || [], (v.data && v.data.portalChildren) || []))
+        collectControls(k, out, false);
+}
+/** CT-1: the controls a component rendered, `listened` from its intent's selectors */
+function controlsOf(r, selectors) {
+    if (!r.controls.size)
+        return undefined;
+    const listened = new Set();
+    for (const s of selectors)
+        for (const m of s.selector.matchAll(/\[data-control="([^"]+)"\]/g))
+            listened.add(m[1]);
+    return [...r.controls].map(([name, { element, kind }]) => ({ name, element, ...(kind ? { kind } : {}), listened: listened.has(name) }));
+}
+/** CT-1: mark a selector that is a control ([data-control="<Key>"]) with its key */
+const withControl = (s) => {
+    const key = keyOfSelector(s.selector);
+    return key ? { ...s, control: key } : s;
+};
+const slim = (d) => {
+    const out = { code: d.code, severity: d.severity, message: d.message };
+    if (d.component)
+        out.component = d.component;
+    if (d.fix)
+        out.fix = d.fix;
+    if (d.docsUrl)
+        out.docsUrl = d.docsUrl;
+    if (d.data !== undefined) {
+        // keep it JSON-safe (data can hold errors, vnodes, ...)
+        try {
+            out.data = JSON.parse(JSON.stringify(d.data));
+        }
+        catch (_) { /* drop */ }
+    }
+    return out;
+};
+function actionsOf(r) {
+    const intent = (r.intentActions || []).filter(a => !r.injected.has(a));
+    const names = uniq([...intent, ...Object.keys(r.modelMap)]).filter(a => typeof a === 'string' && !a.startsWith('__'));
+    const replies = replySeen.get(r.instance);
+    return names.map(name => ({
+        name,
+        trigger: BUILTIN_ACTIONS.has(name) ? 'builtin'
+            : intent.includes(name) ? 'intent'
+                : replies?.has(name) ? 'reply'
+                    : !r.injected.has(name) && r.fired.has(name) ? 'next'
+                        : 'unknown',
+        sinks: [...(r.modelMap[name] || [])],
+    }));
+}
+function stateKeysOf(c, calculated) {
+    const s = c && c.currentState;
+    return isPlainObject(s) ? Object.keys(s).filter(k => !calculated.includes(k)) : [];
+}
+/** PLAN-3 5-3: the instance's resources (`resources` static) and their state slots */
+function resourcesOf(c) {
+    const res = c && c.view && c.view.resources;
+    if (!res || typeof res !== 'object')
+        return undefined;
+    const s = c.currentState || {};
+    return Object.keys(res).map(name => {
+        const r = s[name] || {};
+        return { name, status: r.status ?? 'idle', refreshing: !!r.refreshing, hasData: r.data !== undefined, error: r.error ? String(r.error.message ?? r.error) : undefined };
+    });
+}
+/** PLAN-3 5-3: the cache entries of every makeFetchDriver source the instances use, by sink name (sinks with an empty cache left out) */
+function cacheOf(recs) {
+    const out = {};
+    for (const r of recs) {
+        const sources = r.instance && r.instance.sources;
+        if (!sources || typeof sources !== 'object')
+            continue;
+        for (const k of Object.keys(sources)) {
+            const src = sources[k];
+            if (out[k] || !src || src.__sygnalStatic !== 'resources' || typeof src.__inspect !== 'function')
+                continue;
+            try {
+                const list = src.__inspect().cache;
+                if (list.length)
+                    out[k] = list;
+            }
+            catch (_) { /* a driver without the cache listing */ }
+        }
+    }
+    return out;
+}
+const isScope = (s) => s.startsWith('.___');
+function mockSelectors(mock) {
+    const out = {};
+    mock.listeners.forEach((path, key) => {
+        const scope = path.filter(isScope).pop();
+        const id = mock.scopeIds.get(scope || '');
+        if (id === undefined)
+            return;
+        const sels = path.filter(s => !isScope(s)).join(' ').split(/[\s>]+/).filter(Boolean);
+        const page = !sels.length || /^(document|body)$/.test(sels[0]);
+        const { own, child } = mock.vtree && !page ? mock.probe(sels, scope) : { own: false, child: undefined };
+        (out[id] = out[id] || []).push({
+            selector: sels.join(' '),
+            events: uniq(mock.evTypes[key] || []),
+            matched: mock.vtree && !page ? own : null,
+            isolationHit: !own && child ? mock.owners.get(child) || 'a child component' : null,
+        });
+    });
+    return out;
+}
+function selectorsOf(r, options, diags) {
+    const given = options.selectors && options.selectors[r.id];
+    if (given)
+        return given.map(s => withControl({ ...s }));
+    return (selectorStatus(r.instance) || []).map(({ selector, matched, crossed }) => {
+        const hit = diags.find(d => d.code === 'SYG104' && d.component === r.name && d.data && d.data.selector === selector);
+        const missed = diags.some(d => d.code === 'SYG103' && d.component === r.name && d.data && d.data.selector === selector);
+        return withControl({
+            selector,
+            events: null,
+            matched: matched === null && missed ? false : matched,
+            isolationHit: crossed ? ((hit && hit.data.child) || 'a child component') : null,
+        });
+    });
+}
+function childrenOf(r, all) {
+    const via = { root: 'tag', child: 'tag', 'collection-item': 'collection', switchable: 'switchable' };
+    const out = new Map();
+    for (const c of all) {
+        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 });
+    }
+    return [...out.values()];
+}
+/** The app graph of the live component instances (see ./public.d.ts). */
+function inspect(options = {}) {
+    // report SYG105 (info) for EVENTS types selected but never emitted so far
+    try {
+        checkEventBus();
+    }
+    catch (_) { /* 'error' mode: info never throws; be safe */ }
+    let diags = options.diagnostics || [];
+    if (!options.diagnostics) {
+        attachDevtools();
+        try {
+            diags = (devtools && typeof devtools.getDiagnostics === 'function' && devtools.getDiagnostics()) || [];
+        }
+        catch (_) {
+            diags = [];
+        }
+    }
+    const mock = options.mock;
+    if (mock)
+        options = { ...options, selectors: { ...mockSelectors(mock), ...options.selectors } };
+    const all = [...records.values()];
+    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 components = 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);
+        return {
+            name: r.name,
+            id: r.id,
+            parentId: r.parentId,
+            kind: r.kind,
+            actions: actionsOf(r),
+            stateKeys: stateKeysOf(c, calculated),
+            calculated,
+            contextProvides: c && isPlainObject(c.context) ? Object.keys(c.context) : [],
+            contextConsumes: null,
+            eventsEmitted: [...r.eventsEmitted],
+            eventsSelected: [...r.eventsSelected],
+            children: childrenOf(r, all),
+            selectors,
+            ...(controls ? { controls } : {}),
+            diagnostics: diags.filter(d => d && d.component === r.name).map(slim),
+            ...(resourcesOf(c) ? { resources: resourcesOf(c) } : {}),
+        };
+    });
+    const cache = cacheOf(recs) || {};
+    const events = {};
+    const ev = (type) => events[type] || (events[type] = { emitters: [], selectors: [] });
+    const add = (list, name) => { 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);
+    }
+    // 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);
+    return {
+        version: 1,
+        source: 'runtime',
+        components,
+        events,
+        diagnostics: diags.filter(d => d && (!d.component || !names.has(d.component))).map(slim),
+        ...(Object.keys(cache).length ? { cache } : {}),
+        ...(options.actions ? { recentActions: recentActions(options.actions, ids) } : {}),
+    };
+}
+/** a JSON-safe copy of an action's data (dropped when it doesn't serialize, or is large: a DOM event) */
+function jsonData(d) {
+    if (d === undefined)
+        return {};
+    try {
+        const text = JSON.stringify(d);
+        return text === undefined || text.length > 1000 ? {} : { data: JSON.parse(text) };
+    }
+    catch (_) {
+        return {};
+    }
+}
+/** PLAN-4 2-C: the last `limit` actions (true: all kept) of the listed instances */
+function recentActions(limit, ids) {
+    const list = ids ? recent.filter(r => ids.has(r.instance)) : recent;
+    const n = limit === true ? list.length : Math.max(0, Math.floor(limit));
+    return list.slice(list.length - n).map(r => ({
+        type: r.type,
+        ...jsonData(r.data),
+        component: r.component,
+        instance: r.instance,
+        sinks: [...r.sinks],
+        cause: r.cause,
+        at: r.time - epoch,
+    }));
+}
+/** Publish inspect() on the core bridge and the devtools object. Returns an uninstall function. */
+function installInspect() {
+    const core = bridge();
+    if (core)
+        core.inspect = inspect;
+    attachDevtools();
+    return () => {
+        if (core && core.inspect === inspect)
+            core.inspect = undefined;
+        const dt = globalThis.__SYGNAL_DEVTOOLS__;
+        if (dt && dt.inspect === inspect) {
+            try {
+                delete dt.inspect;
+            }
+            catch (_) { /* ignore */ }
+        }
+    };
+}
+
+/**
+ * PLAN-4.6 R4: the dev entry's checks on the next component core (src/core/).
+ *
+ * The core has no instance to patch and no diagnostics calls of its own: it reads this
+ * entry's hooks once per app (`__SYGNAL_DIAGNOSTICS__.nextHooks(api)`, 04-hooks-contract §2.2)
+ * and calls them with read-only InstanceViews. This module maps them onto the existing checks:
+ *
+ * - each instance gets a facade with the fields the checks read from today's instances (name,
+ *   view, model, sources, currentState, ...), so the DiagnosticCheck hooks (onIntent, onModel,
+ *   onRender, onReducer, onDispose, sources) run unchanged through the core's dispatchers;
+ * - what the checks did by patching an instance becomes a hook: SYG222's reducer wrapping
+ *   (wrapHandler), the reply / fetch / EVENTS taps of a sink (onSink), the ELEMENT check
+ *   (onElementCommand), the Collection check (onHostProps), the action log (actionLog.ts);
+ * - the core's own dev codes: SYG423 (D168: a view context tracking skipped would have
+ *   rendered differently), SYG424 (D169/D177: duplicate Collection ids), SYG425 (D174: an
+ *   isolatedState child kept a slice that lacks its initialState keys), SYG148 / SYG149 (G-419:
+ *   a Collection's viewTransitionName that isn't an identifier, the same name twice on the
+ *   page after a patch, G-460: on rendered elements), SYG612 (D173: a form
+ *   6.0 removed, met at runtime; once per form and component, with a link to the migration
+ *   guide).
+ *
+ * Only while diagnostics are on (the checks' own rule); production builds never load this.
+ */
+const MIGRATE = 'https://sygnal.js.org/guide/migrating-to-6';
+/** the removed forms (D162-D164) by migration-guide anchor: what it was, how to write it now */
+const REMOVED = {
+    'string-tags': ['a component named by a string tag (<Name /> as a string, looked up in .components)', 'Import the component and use it as a JSX tag: <Badge />'],
+    'components': ['the .components registry', 'Import each component and use it as a JSX tag; remove .components'],
+    'collection-of-name': ['<Collection of="Name"> (a name)', 'Pass the component itself: <Collection of={Item} from="items" />'],
+    'collection-wrapper': ["the Collection's wrapper element (className, style, class, attrs, data-*, on, ref or hook on <Collection>)", 'Collection renders its items directly into its parent: put them on your own wrapping element, <ul className="x"><Collection of={Item} from="items" /></ul>'],
+    'child-select-name': ["CHILD.select('Name') (a name)", 'Pass the component itself: CHILD.select(Item)'],
+    'pipe-keys': ["'ACTION | SINK' model keys", "Use the object form: ACTION: { SINK: (state, data) => ... }"],
+    'peers': ['.peers', 'Render the peer as a sibling in the parent view'],
+    'hmractions': ['hmrActions', 'Remove hmrActions; sygnal/vite keeps the state across a hot update'],
+    'positional-views': ['a view with positional parameters (props, state, context, peers)', 'Destructure the one argument: function C({ state, context, ...props })'],
+    'source-names': ['DOMSourceName / stateSourceName', "Remove them: the sources are always DOM and STATE"],
+    'storecalculatedinstate': ['storeCalculatedInState', 'Remove it: calculated fields are always part of the state the view and reducers get'],
+    'component-factory': ['the component({ ... }) factory (with sources / isolateOpts)', 'Write a function component with statics (C.model, C.intent, C.initialState), or use defineComponent({ ... })'],
+};
+/** 4-H: the marker's props / data buckets the removed Collection wrapper element took */
+const WRAPPER = ['className', 'style', 'class', 'attrs', 'dataset', 'on', 'hook'];
+const STATICS = [['components', 'components'], ['peers', 'peers'], ['hmrActions', 'hmractions'], ['DOMSourceName', 'source-names'], ['stateSourceName', 'source-names'], ['storeCalculatedInState', 'storecalculatedinstate']];
+function removed(component, name, anchor, detail) {
+    if (!once(`SYG612:${name}:${anchor}`))
+        return;
+    const [what, fix] = REMOVED[anchor];
+    devReport('SYG612', {
+        component: name,
+        message: `${name} uses ${what}${detail ? ` (${detail})` : ''}, which Sygnal 6.0 removed, so it is ignored or fails`,
+        fix: `${fix}. See ${MIGRATE}#${anchor}`,
+        data: { form: anchor, guide: `${MIGRATE}#${anchor}`, ...(detail ? { detail } : {}) },
+    });
+}
+/** the removed forms a definition shows (statics, view arity, model keys), once per function */
+let seenDefs = new WeakSet();
+// G-332: resetChecks() forgets them (as the once() dedupe)
+onReset(() => { seenDefs = new WeakSet(); });
+function removedStatics(f) {
+    const view = f.view;
+    if (!view || seenDefs.has(view))
+        return;
+    seenDefs.add(view);
+    const name = f.name;
+    if (view.isSygnalComponent)
+        removed(f, name, 'component-factory');
+    for (const [k, anchor] of STATICS)
+        if (view[k] !== undefined && !(k == 'components' && isPlainObject(view[k]) && !Object.keys(view[k]).length))
+            removed(f, name, anchor, k);
+    // G-343: a defineComponent() wrapper's own arity is 1; the view it calls is __sygnalView
+    const arity = typeof view == 'function' ? (view.__sygnalView || view).length : 0;
+    if (arity > 1 && !view.__sygnalLazy && !view.isSygnalComponent)
+        removed(f, name, 'positional-views', `${arity} parameters`);
+    const model = view.model;
+    if (isPlainObject(model))
+        for (const k of Object.keys(model))
+            if (k.includes('|'))
+                removed(f, name, 'pipe-keys', `'${k}'`);
+}
+/** string tags left in a rendered vnode (the core renders them as elements) */
+function removedTags(f, v, depth = 0) {
+    if (!v || typeof v != 'object' || depth > 300)
+        return;
+    const sel = v.sel;
+    // G-329: a component name is PascalCase; an all-caps tag (h('SPAN'), h(el.tagName)) is an element
+    const tag = typeof sel == 'string' ? sel.split(/[.#]/)[0] : '';
+    if (/^[A-Z]/.test(tag) && /[a-z]/.test(tag) && !(v.data && v.data.c))
+        removed(f, f.name, 'string-tags', `<${tag}>`);
+    const kids = v.children;
+    if (Array.isArray(kids))
+        for (const k of kids)
+            removedTags(f, k, depth + 1);
+}
+/** the instance fields the checks read from today's Component instances */
+class Facade {
+    constructor(__next) {
+        this.__next = __next;
+    }
+    get name() { return this.__next.name; }
+    get view() { return this.__next.def.view; }
+    get model() {
+        const m = {};
+        this.__next.def.handlers.forEach((hs, a) => { const e = m[a] = {}; for (const [s, fn] of hs)
+            e[s] = fn; });
+        return m;
+    }
+    get modelMap() {
+        const m = {};
+        this.__next.def.handlers.forEach((hs, a) => { m[a] = hs.map(h => h[0]); });
+        // the built-in INITIALIZE (today's model map ends with it for every component)
+        if (!m.INITIALIZE)
+            m.INITIALIZE = ['STATE'];
+        return m;
+    }
+    get sources() { return this._so || this.__next.sources; }
+    get sourceNames() { return Object.keys(this.__next.sources); }
+    get stateSourceName() { return 'STATE'; }
+    get DOMSourceName() { return 'DOM'; }
+    get isSubComponent() { return !this.__next.isRoot; }
+    get initialState() { return this.__next.def.initialState; }
+    get currentState() { return this.__next.state; }
+    get currentProps() { return this.__next.props; }
+    get currentContext() { return this.__next.context; }
+    get _componentNumber() { return this.__next.id; }
+    get calculated() { return this.__next.def.view.calculated; }
+    get _calculatedFieldNames() { return this.__next.def.calcNames; }
+    get context() { return this.__next.def.view.context; }
+    get _uses() { return Object.entries(this.__next.def.view.uses || {}); }
+    get _behaviorActions() { return this.__next.def.behaviorActions; }
+    get intent$() { return { __sygnalTestActions: this.__next.def.testActions || [] }; }
+    get _disposed() { return this.__next.disposed; }
+    /** the state already has its calculated fields */
+    addCalculated(s) { return s; }
+}
+const facades = new WeakMap();
+const fac = (iv) => {
+    let f = facades.get(iv);
+    if (!f)
+        facades.set(iv, f = new Facade(iv));
+    return f;
+};
+/** structural vnode equality (functions equal: a view may make new closures every call) */
+function same(a, b, d = 0) {
+    if (a === b || (typeof a == 'function' && typeof b == 'function'))
+        return true;
+    if (!a || !b || typeof a != 'object' || typeof b != 'object')
+        return a !== a && b !== b;
+    if (d > 300)
+        return true;
+    if (Array.isArray(a) != Array.isArray(b))
+        return false;
+    const ka = Object.keys(a).filter(k => k != 'elm' && a[k] !== undefined), kb = Object.keys(b).filter(k => k != 'elm' && b[k] !== undefined);
+    if (ka.length != kb.length)
+        return false;
+    for (const k of ka)
+        if (!same(a[k], b[k], d + 1))
+            return false;
+    return true;
+}
+const SAMPLE = 16, CAP = 20;
+/** a CSS identifier's start, then identifier characters (`<prefix>-<id>` is one when the prefix starts one) */
+const IDENT = /^(--|-?[A-Za-z_\u0080-\uffff])[\w\u0080-\uffff-]*$/;
+/** G-419 SYG148: a Collection's viewTransitionName that is not a CSS identifier (true: a valid one) */
+function vtPrefix(name, p) {
+    if (typeof p == 'string' && IDENT.test(p))
+        return true;
+    const shown = typeof p == 'string' ? JSON.stringify(p) : `{${typeof p}}`;
+    if (once(`SYG148:${name}:${String(p)}`))
+        devReport('SYG148', {
+            component: name,
+            message: `A Collection in ${name} has viewTransitionName=${shown}, which is not a CSS identifier, so every item's view-transition-name (${typeof p == 'string' ? p : '<prefix>'}-<id>) is invalid CSS: the browser ignores it and nothing animates`,
+            fix: 'Use a CSS identifier as the prefix: letters, digits, - and _, not starting with a digit (viewTransitionName="card")',
+            data: { value: p },
+        });
+    return false;
+}
+/**
+ * G-460: an element the browser renders (a View Transition captures only those): not in a
+ * display: none subtree (a hidden tab panel, a list shown only at another width). checkVisibility()
+ * where there is one; else (jsdom) no display: none on it or an ancestor
+ */
+function rendered(el) {
+    if (!el?.isConnected)
+        return false;
+    if (typeof el.checkVisibility == 'function')
+        return el.checkVisibility();
+    const cs = el.ownerDocument?.defaultView?.getComputedStyle;
+    for (let n = el; n && n.nodeType == 1; n = n.parentNode)
+        if (n.hidden || cs?.(n).display == 'none')
+            return false;
+    return true;
+}
+/**
+ * G-419 SYG149: two elements of the patched page with the same view-transition-name from
+ * Collections with the same prefix (the same id shown in two of them): the browser skips the
+ * whole View Transition. Walks the vnode tree (dev only, while a named Collection is mounted);
+ * G-460: a name found twice is checked on the DOM after the patch (a microtask later; when a View
+ * Transition defers the patch, again a little later): only rendered elements count. Returns the
+ * groups of vnodes with one name (none: an empty list)
+ */
+function vtDuplicates(root, prefixes) {
+    const seen = new Map(), dup = [];
+    const stack = [root];
+    while (stack.length) {
+        const v = stack.pop();
+        if (!v || typeof v != 'object')
+            continue;
+        const st = v.data?.style, n = st?.viewTransitionName;
+        if (typeof n == 'string' && prefixes.has(st.viewTransitionClass)) {
+            const g = seen.get(n);
+            if (!g)
+                seen.set(n, [v]);
+            else if (g.push(v) == 2)
+                dup.push(g);
+        }
+        if (Array.isArray(v.children))
+            for (let i = v.children.length; i--;)
+                stack.push(v.children[i]);
+    }
+    return dup;
+}
+// G-538: a fragment root never gets an element (the DOM driver flattens it into the container):
+// it has run when each of its children has one (a kept child has its old one: a View Transition
+// patch of a fragment root whose children are all kept is checked before it runs)
+const patched = (v) => v.elm || !v.sel && v.children?.every((c) => !c || patched(c));
+/**
+ * G-527: the patches waiting for their SYG149 check ([root vnode, duplicate groups], newest last,
+ * at most 8) and one chain of checks over them: a microtask after the first, then every 50 ms
+ * while some wait. The patch of a root has run when it has its element (a View Transition patches
+ * in its update callback, and replaces a held vnode it hasn't patched yet; kept vnodes have their
+ * old elements before that): each check takes the newest patch that ran and drops it and the older
+ * ones. A newer patch joins the queue and doesn't restart the chain, so patches closer than 50 ms
+ * (View Transitions back to back) can't starve it. A patch without duplicates joins only a queue
+ * that waits (once it has run, the older ones are moot). G-501: the chain stops once the app (or
+ * every named Collection) is gone, and after 10 tries without a patched root (the mock DOM; a root
+ * that never gets its element isn't checked on its children's old elements)
+ */
+function vtChecker(live) {
+    let q = [], busy = false, tries = 0;
+    const vtRendered = () => {
+        if (!live()) {
+            q = [];
+            busy = false;
+            return;
+        }
+        let i = q.length;
+        while (i-- && !patched(q[i][0]))
+            ;
+        if (i >= 0) {
+            vtReport(q[i][1]);
+            q = q.slice(i + 1);
+            tries = 0;
+        }
+        else
+            tries++;
+        if (!q.length || tries > 10) {
+            q = [];
+            busy = false;
+            return;
+        }
+        setTimeout(vtRendered, 50);
+    };
+    return (root, dup) => {
+        if (!dup.length && !q.length)
+            return;
+        q.push([root, dup]);
+        if (q.length > 8)
+            q.shift();
+        if (!busy) {
+            busy = true;
+            tries = 0;
+            queueMicrotask(vtRendered);
+        }
+    };
+}
+function vtReport(dup) {
+    for (const g of dup) {
+        const v = g[0], st = v.data.style, n = st.viewTransitionName;
+        if (g.filter(x => rendered(x.elm)).length < 2 || !once(`SYG149:${n}`))
+            continue;
+        devReport('SYG149', {
+            component: 'Collection',
+            message: `Two elements on the page have view-transition-name '${n}': Collections with viewTransitionName="${st.viewTransitionClass}" show the item with that id at the same time. Names must be unique when a View Transition starts, so the browser skips every transition while both are shown`,
+            fix: `Give Collections that can show the same item at once different prefixes (viewTransitionName="${st.viewTransitionClass}" and another), or name the item yourself with its own style`,
+            data: { name: n, prefix: st.viewTransitionClass },
+        });
+    }
+}
+/** The hooks one app gets (installChecks publishes this on the bridge). */
+function nextHooks(_api) {
+    const core = bridge(), H = core.hooks;
+    const on = () => H.on();
+    const modelOf = (f) => f.modelMap;
+    const wired = new WeakSet();
+    const wire = (iv, names) => {
+        const f = fac(iv);
+        if (wired.has(f))
+            return;
+        wired.add(f);
+        H.onIntent(f, names);
+        H.onModel(f, modelOf(f));
+    };
+    // D168: the views context tracking skipped, checked on a sample (each instance's first two
+    // skips, then 1 in 16; at most CAP per tick)
+    const skips = new WeakMap();
+    let budget = 0;
+    const log = actionHooks(actionListener, () => on());
+    // G-419: the viewTransitionName prefixes this app's Collections use; G-460: per instance that
+    // renders them, so the SYG149 walk stops once every one of them is disposed
+    const vtp = new Map();
+    // G-527: one chain of SYG149 checks over the latest patches (G-501: it stops once every instance
+    // that renders a named Collection is disposed, the app's dispose included)
+    const vtCheck = vtChecker(() => vtp.size && on());
+    return {
+        onCreate(iv) {
+            if (!on())
+                return;
+            log.onCreate(iv);
+            const f = fac(iv);
+            removedStatics(f);
+            if (!iv.def.intent)
+                wire(iv, []);
+        },
+        wrapSources(iv, so) {
+            const f = fac(iv);
+            f._so = so;
+            let out;
+            try {
+                out = H.sourcesFor(f);
+            }
+            finally {
+                f._so = undefined;
+            }
+            if (!on() || typeof Proxy != 'function')
+                return out;
+            // D173: CHILD.select('Name')
+            const s = out || so;
+            return new Proxy(s, {
+                get(t, k) {
+                    const v = t[k];
+                    if (k !== 'CHILD' || !v || typeof v.select != 'function')
+                        return v;
+                    return { ...v, select: (x, ...r) => { if (typeof x == 'string')
+                            removed(f, f.name, 'child-select-name', `CHILD.select('${x}')`); return v.select(x, ...r); } };
+                },
+            });
+        },
+        onIntent(iv, names) {
+            wire(iv, names);
+        },
+        onRender(iv, vnode) {
+            const f = fac(iv);
+            H.onRender(f, vnode);
+            if (on())
+                removedTags(f, vnode);
+        },
+        onReducer(iv, type, prev, next) {
+            H.onReducer(fac(iv), type, prev, next, 'STATE');
+        },
+        onDispose(iv) {
+            vtp.delete(iv);
+            H.onDispose(fac(iv));
+        },
+        onAction(iv, a) { log.onAction(iv, a); },
+        wrapHandler(iv, type, sink, fn) {
+            let h = log.wrapHandler(iv, type, sink, fn) || fn;
+            // 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;
+        },
+        onSink(iv, type, sink, v) {
+            if (!on())
+                return;
+            const f = fac(iv), src = iv.sources[sink];
+            try {
+                if (sink == 'EVENTS')
+                    eventEmitted(f, v);
+                if (src && src.__sygnalReplies === true)
+                    checkRequest(f, sink, v, Object.keys(f.modelMap));
+                if (src && src.__sygnalStatic === 'resources')
+                    check(f, sink, v);
+            }
+            catch (_) { /* a check never breaks the app */ }
+        },
+        onElementCommand(iv, cmd) {
+            if (!on())
+                return;
+            const f = fac(iv);
+            for (const c of [].concat(cmd))
+                checkSentCommand(f, c);
+        },
+        onHostProps(owner, sel, props, data) {
+            if (!on() || (sel != 'collection' && sel != 'virtual-collection'))
+                return;
+            const f = fac(owner);
+            if (typeof props.of == 'string')
+                removed(f, f.name, 'collection-of-name', `of="${props.of}"`);
+            // 4-H (D229): what went only to the removed wrapper div (VirtualCollection keeps its container)
+            if (sel == 'collection') {
+                const w = WRAPPER.filter(k => k == 'className' ? props.className != null : data?.[k] != null);
+                if (w.length)
+                    removed(f, f.name, 'collection-wrapper', w.map(k => k == 'dataset' ? 'data-*' : k == 'hook' ? 'ref / hook' : k).join(', '));
+            }
+            try {
+                checkCollection(f, { data: { props } });
+            }
+            catch (_) { /* ignore */ }
+            // G-419: SYG148 for a prefix that isn't an identifier; a valid one is checked for
+            // duplicate names after each patch (SYG149). G-460: a falsy one names nothing (as the host)
+            const p = props.viewTransitionName;
+            if (p && vtPrefix(f.name, p)) {
+                let s = vtp.get(owner);
+                if (!s)
+                    vtp.set(owner, s = new Set());
+                s.add(p);
+            }
+        },
+        onPatch(vnode) {
+            if (!vtp.size || !on())
+                return;
+            const all = new Set();
+            for (const s of vtp.values())
+                for (const p of s)
+                    all.add(p);
+            try {
+                vtCheck(vnode, vtDuplicates(vnode, all));
+            }
+            catch (_) { /* a check never breaks the app */ }
+        },
+        onDuplicateKey(owner, key) {
+            if (!on())
+                return;
+            const name = owner.name;
+            if (!once(`SYG424:${name}:${String(key)}`))
+                return;
+            devReport('SYG424', {
+                component: name,
+                message: `A Collection in ${name} has more than one item with the id ${JSON.stringify(key) ?? String(key)} (duplicate ids); only the first of them renders, and their writes go to it`,
+                fix: 'Give every item a unique id (or no id: an item without one is keyed by its index)',
+                data: { id: key },
+            });
+        },
+        onStateSeed(iv, slice, init) {
+            if (!on() || !isPlainObject(init) || !isPlainObject(slice))
+                return;
+            // G-333: a key initialState sets to undefined is no data the slice lacks
+            const missing = Object.keys(init).filter(k => init[k] !== undefined && !(k in slice));
+            const name = iv.name;
+            if (!missing.length || !once(`SYG425:${name}:${missing.join(',')}`))
+                return;
+            const list = missing.map(k => `'${k}'`).join(', ');
+            devReport('SYG425', {
+                component: name,
+                message: `${name} has isolatedState and is bound to a slice of its parent's state that already exists, so it keeps that slice instead of its initialState; the slice has no ${list}, which ${name}.initialState defines`,
+                fix: `To start ${name} from its initialState instead, add resetState to the tag (<${name} state="..." resetState />). To keep the parent's data, initialize ${list} in the parent's state`,
+                data: { missing, slice: Object.keys(slice) },
+            });
+        },
+        onContextSkip(iv, render, prev, next, keys) {
+            if (!on() || !prev || !next)
+                return;
+            const n = (skips.get(iv) || 0) + 1;
+            skips.set(iv, n);
+            if ((n > 2 && n % SAMPLE) || budget >= CAP)
+                return;
+            if (!budget++)
+                queueMicrotask(() => { budget = 0; });
+            let a, b, c;
+            try {
+                a = render(prev);
+                b = render(next);
+                c = render(prev);
+            }
+            catch (_) {
+                return;
+            }
+            // G-327: a control render: a view whose output differs between two calls with the same
+            // context (a render counter, Date.now(), Math.random(), generated ids) proves nothing
+            if (same(a, b) || !same(a, c))
+                return;
+            const name = iv.name;
+            const changed = Object.keys(next).filter(k => next[k] !== prev[k]);
+            if (!once(`SYG423:${name}`))
+                return;
+            reportSafely('SYG423', {
+                severity: DEV_CODE_SEVERITY.SYG423,
+                component: name,
+                message: `The context keys ${changed.map(k => `'${k}'`).join(', ')} changed and ${name}'s view was not re-rendered, because the view read none of them during its last call (it read: ${keys.length ? keys.map(k => `'${k}'`).join(', ') : 'nothing'}). Calling it with the new context renders something else, so the page shows a stale render`,
+                fix: `Read context entries in the view itself (context.theme), not through a value kept from an earlier render or a function that runs later; Object.getOwnPropertyDescriptor and similar reflection aren't tracked`,
+                data: { keysRead: keys, changed },
+            });
+        },
+    };
+}
+
+/** Every runtime check in this entry. */
+const checks = [
+    wiringCheck,
+    stateCheck,
+    eventsCheck,
+    propsCheck,
+    collectionsCheck,
+    domCheck,
+    shorthandCheck,
+    controlsCheck,
+    elementCommandsCheck,
+    behaviorsCheck,
+    formsCheck,
+    datasetCheck,
+    strictCheck,
+    repliesCheck,
+    routerCheck,
+    fetchCheck,
+    timersCheck,
+    persistCheck,
+    viewTransitionsCheck,
+    staticsCheck,
+    inspectCheck,
+];
+/**
+ * (Re-)register all checks with the core and install the RxJS hints. Called
+ * on import. Idempotent across duplicate copies of this entry: the previous
+ * installation (stored on the core bridge) is removed first.
+ */
+function installChecks() {
+    const core = bridge();
+    if (!core)
+        throw new Error(`[Sygnal] 'sygnal/diagnostics' could not find the Sygnal diagnostics core`);
+    if (typeof core.__uninstallChecks === 'function')
+        core.__uninstallChecks();
+    const unregister = checks.map(check => core.registerCheck(check));
+    const uninstallHints = installRxjsHints(Stream && Stream.prototype);
+    const uninstallInspect = installInspect();
+    const uninstallRouter = installRouterHooks();
+    const uninstallControls = installControlHooks();
+    const uninstallTimers = installTimerHooks();
+    const uninstallBrowser = installBrowserSourceHooks();
+    const uninstallElementCommands = installElementCommandHooks();
+    const uninstallWidgets = installWidgetHooks();
+    const uninstallVirtual = installVirtualHooks();
+    const uninstallForms = installFormHooks();
+    const uninstallSortable = installSortableHooks();
+    (core.layers || (core.layers = new Set())).add(nextHooks);
+    const uninstall = () => {
+        core.layers?.delete(nextHooks);
+        unregister.forEach(fn => fn());
+        uninstallHints();
+        uninstallInspect();
+        uninstallRouter();
+        uninstallControls();
+        uninstallTimers();
+        uninstallBrowser();
+        uninstallElementCommands();
+        uninstallWidgets();
+        uninstallVirtual();
+        uninstallForms();
+        uninstallSortable();
+        if (core.__uninstallChecks === uninstall)
+            core.__uninstallChecks = undefined;
+    };
+    core.__uninstallChecks = uninstall;
+    return uninstall;
+}
+/** Tune the timing of the DOM checks (mostly for tests). */
+function configureChecks(options = {}) {
+    for (const key of Object.keys(timing)) {
+        if (typeof options[key] === 'number')
+            timing[key] = options[key];
+    }
+}
+/** Forget what the checks have seen and reported (dedupe state, registries). For tests. */
+function resetChecks() {
+    resetCheckState();
+}
+installChecks();
+
+export { RXJS_HINTS, checkEventBus, checks, configureChecks, configureStrict, getCodeInfo, inspect, installChecks, isStrictEnabled, listCodes, resetChecks };
+//# sourceMappingURL=diagnostics.esm.js.map