sygnal 5.3.6 → 5.4.0

package/dist/diagnostics.cjs.js

@@ -0,0 +1,1297 @@
+'use strict';
+
+var ns = require('xstream');
+require('sygnal');
+
+function _interopNamespaceDefault(e) {
+    var n = Object.create(null);
+    if (e) {
+        Object.keys(e).forEach(function (k) {
+            if (k !== 'default') {
+                var d = Object.getOwnPropertyDescriptor(e, k);
+                Object.defineProperty(n, k, d.get ? d : {
+                    enumerable: true,
+                    get: function () { return e[k]; }
+                });
+            }
+        });
+    }
+    n.default = e;
+    return Object.freeze(n);
+}
+
+var ns__namespace = /*#__PURE__*/_interopNamespaceDefault(ns);
+
+const d = ns__namespace.default;
+const xs$1 = d && typeof d.create === 'function' ? d : d && d.default && typeof d.default.create === 'function' ? d.default : ns__namespace;
+
+var xstreamNamespace = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    MemoryStream: ns.MemoryStream,
+    NO: ns.NO,
+    NO_IL: ns.NO_IL,
+    Stream: ns.Stream,
+    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 = ns.Stream ||
+    (xs$1 && xs$1.Stream) ||
+    (xs && xs.Stream);
+
+/**
+ * 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;
+    }
+};
+/** 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". */
+const BUILTIN_ACTIONS = new Set(['BOOTSTRAP', 'INITIALIZE', 'HYDRATE', 'DISPOSE', 'READY']);
+/** 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));
+/**
+ * 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(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(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();
+const wiringCheck = {
+    id: 'wiring',
+    onIntent(component, actionNames) {
+        intentActions.set(component, actionNames || []);
+    },
+    onModel(component, modelMap) {
+        const name = nameOf(component);
+        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 },
+            });
+        }
+        // A single-stream intent (intent returns one action$ stream) has no
+        // action names to compare against.
+        if (intent$ && typeof intent$.addListener === 'function')
+            return;
+        const hmr = [].concat(component?.hmrActions || []);
+        for (const action of modelActions) {
+            if (isInternalAction(action) || actions.includes(action) || hmr.includes(action) || injected.has(action))
+                continue;
+            if (!once(`SYG102:${name}:${action}`))
+                continue;
+            report('SYG102', {
+                component,
+                message: `Model entry '${action}' has no intent action with that name${didYouMean(action, actions)}`,
+                fix: `Add '${action}' to ${name}.intent, or remove the model entry. If it is only dispatched with next('${action}'), ignore this`,
+                data: { action, intentActions: actions },
+            });
+        }
+    },
+};
+
+const SKIP = new Set(['INITIALIZE', 'HYDRATE']);
+const stateCheck = {
+    id: 'state',
+    onReducer(component, action, prevState, nextState) {
+        if (typeof action !== 'string' || action.startsWith('__') || SKIP.has(action))
+            return;
+        const name = nameOf(component);
+        if (nextState === undefined) {
+            if (!once(`SYG202:${name}:${action}`))
+                return;
+            // Returning undefined from a Collection item's reducer is the documented way to remove
+            // the item, so only the root (where it wipes the whole app state) is a warning.
+            const sub = !!component?.isSubComponent;
+            report('SYG202', {
+                component,
+                severity: sub ? 'info' : 'warn',
+                message: `The STATE reducer for '${action}' returned undefined` +
+                    (sub ? ' (this removes the item if the component is a Collection item)' : ''),
+                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;
+        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 = new Set();
+let emitted = new Set();
+let selectsAll = false;
+onReset(() => { selected = 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.add(t);
+    },
+    onBusEmit(type, emitterName) {
+        if (typeof type !== 'string')
+            return;
+        emitted.add(type);
+        if (selectsAll || selected.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)}`,
+            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].filter(t => !emitted.has(t));
+    const emittedNeverSelected = selectsAll ? [] : [...emitted].filter(t => !selected.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], emitted: [...emitted], selectedNeverEmitted, emittedNeverSelected };
+}
+
+const RESERVED = ['children', 'slots', 'context', 'peers'];
+const propsCheck = {
+    id: 'props',
+    onRender(component) {
+        const props = component && component.currentProps;
+        if (!props || typeof props !== 'object')
+            return;
+        const name = nameOf(component);
+        for (const key of RESERVED) {
+            if (!(key in props) || !once(`SYG106:${name}:${key}`))
+                continue;
+            report('SYG106', {
+                component,
+                severity: 'warn',
+                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: 'warn',
+                    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 = (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(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;
+    }
+}
+
+const scopesOf = (ns) => ns.filter(s => s.type !== 'selector');
+const keyOf = (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) || []);
+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));
+}
+function rootElementOf(t) {
+    try {
+        const im = t.source._isolateModule;
+        return im && im.getElement(scopesOf(t.source.namespace));
+    }
+    catch (_) {
+        return undefined;
+    }
+}
+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(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 root = rootElementOf(t);
+    if (!root || typeof root.querySelectorAll !== 'function')
+        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 = 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';
+            reportSafely('SYG104', {
+                component,
+                message: `DOM.select('${selector}') in ${t.name} matches elements inside ${child} (isolated), so ${t.name} never receives their events`,
+                fix: `Handle the event in ${child} and send it up with PARENT (read it here with CHILD.select(${child})), or use EVENTS`,
+                data: { 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(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(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);
+    },
+};
+
+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: 'warn',
+    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',
+    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',
+    // 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: 'View uses positional arguments',
+    SYG502: 'STATE reducer signals no change without ABORT',
+    SYG503: 'Side effect in a STATE reducer that returns ABORT',
+    SYG504: "'ACTION | SINK' shorthand model key",
+    SYG505: 'Non-canonical EVENTS emit',
+    SYG506: 'CHILD.select() with a string component name',
+    SYG507: 'Prop drilled through more than 2 component levels',
+    // 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: 'Invalid model shorthand entry',
+    SYG212: 'Model entry is not a function or an object of sinks',
+    SYG213: 'Duplicate model entry for the same action and sink',
+    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',
+    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: 'Unnamed component factory not found',
+    SYG414: 'Component not found',
+    SYG415: "Switchable 'of' is missing or invalid",
+    SYG416: "Switchable 'current' is missing or invalid",
+    SYG417: 'Portal target not found',
+    SYG418: 'Invalid Collection sort prop',
+    SYG419: "Invalid switchable() 'name$' parameter",
+    SYG420: 'JSX tag is undefined',
+    SYG601: 'Missing or invalid sources',
+    SYG602: 'Intent is not a function',
+    SYG603: 'Intent returned an invalid value',
+    SYG604: 'Invalid hmrActions',
+    SYG605: "Intent action name contains '|'",
+    SYG606: 'calculated is not an object',
+    SYG607: 'State source not found',
+    SYG901: 'Sub-component sink stream errored',
+    SYG902: 'EFFECT stream errored',
+    SYG903: 'Component factory returned invalid sinks',
+    // ---- 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: 'warn',
+    SYG502: 'warn',
+    SYG503: 'warn',
+    SYG504: 'warn',
+    SYG505: 'warn',
+    SYG506: 'warn',
+    SYG507: 'info',
+};
+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()}`;
+}
+
+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;
+}
+const strictReport = (code, details) => report(code, { severity: STRICT_CODE_SEVERITY[code], ...details });
+const strictCheck = {
+    id: 'strict',
+    onModel(component) {
+        if (!isStrictEnabled() || !component)
+            return;
+        const name = nameOf(component);
+        // SYG501 — view(props, state, context, peers): positional use of the 2nd+ args.
+        // (A default value or a rest parameter stops Function.length, so this can
+        // miss `(props, state = {})`, but it never flags a single-argument view.)
+        const view = component.view;
+        if (typeof view === 'function' && view.length > 1 && !view.__sygnalLazy && once(`SYG501:${name}`)) {
+            const extra = ['state', 'context', 'peers'].slice(0, view.length - 1);
+            strictReport('SYG501', {
+                component,
+                message: `The view takes ${view.length} positional arguments (props, ${extra.join(', ')})`,
+                fix: `Destructure the first argument instead: function ${name}({ ${extra.join(', ')}, ...props })`,
+                data: { arity: view.length },
+            });
+        }
+        // SYG504 — 'ACTION | SINK' shorthand keys
+        const model = component.model;
+        if (!model || typeof model !== 'object')
+            return;
+        for (const key of Object.keys(model)) {
+            if (!key.includes('|'))
+                continue;
+            const [action, sink] = key.split('|').map(s => s.trim());
+            if (!action || !sink || !once(`SYG504:${name}:${key}`))
+                continue;
+            const rewrite = sink === 'EVENTS'
+                ? `${action}: { EVENTS: event('TYPE', (state, data) => payload) }`
+                : `${action}: { ${sink}: (state, data, next) => ... }`;
+            strictReport('SYG504', {
+                component,
+                message: `Model key '${key}' uses the 'ACTION | SINK' shorthand`,
+                fix: `Use the object form: ${rewrite} (merge it into an existing '${action}' entry if there is one)`,
+                data: { key, action, sink },
+            });
+        }
+    },
+    onReducer(component, action, prevState, nextState) {
+        if (!isStrictEnabled() || isInternalAction(action))
+            return; // incl. INITIALIZE/HYDRATE/DISPOSE
+        // undefined is SYG202 (state check, every mode); only the identical object here.
+        if (!prevState || typeof prevState !== 'object' || nextState === undefined)
+            return;
+        let same = nextState === prevState;
+        if (!same && typeof component?.addCalculated === 'function') {
+            // with calculated fields the reducer saw addCalculated(prev) (memoized: same object)
+            try {
+                same = component.addCalculated(prevState) === nextState;
+            }
+            catch (_) { }
+        }
+        const name = nameOf(component);
+        if (!same || !once(`SYG502:${name}:${action}`))
+            return;
+        strictReport('SYG502', {
+            component,
+            message: `The STATE reducer for '${action}' returned the unchanged state object`,
+            fix: `Return ABORT for "no change": ${action}: (state, data) => cond ? { ...state, ... } : ABORT`,
+            data: { action },
+        });
+    },
+};
+
+/**
+ * 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 component.ts.
+ *
+ * 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]; };
+}
+
+let records = new Map();
+let pendingSelects = [];
+/** every EVENTS type seen on the bus */
+let busTypes = new Set();
+onReset(() => {
+    records = new Map();
+    pendingSelects = [];
+    busTypes = new Set();
+});
+const uniq = (list) => [...new Set(list)];
+function kindOf(c) {
+    const s = (c && c.sources) || {};
+    if (typeof s.__parentComponentNumber !== 'number')
+        return 'root';
+    // Collection items get PARENT: null (src/component.ts instantiateCollection)
+    if ('PARENT' in s && s.PARENT === null)
+        return 'collection-item';
+    // switchable() adds a lower-case `state` source next to the component's own (src/switchable.ts)
+    if (c.stateSourceName !== 'state' && 'state' in s && s.state !== s[c.stateSourceName])
+        return 'switchable';
+    return 'child';
+}
+function ensure(c) {
+    let r = records.get(c);
+    if (!r) {
+        const parent = c && c.sources && c.sources.__parentComponentNumber;
+        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(),
+        };
+        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 = intent$ && typeof intent$.addListener === 'function' ? null : (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 || {};
+        const model$ = component && component.model$;
+        const events$ = model$ && model$.EVENTS;
+        if (events$ && typeof events$.map === 'function' && !events$.__sygnalInspect) {
+            const tapped = events$.map((ev) => {
+                if (ev && typeof ev.type === 'string')
+                    r.eventsEmitted.add(ev.type);
+                return ev;
+            });
+            tapped.__sygnalInspect = true;
+            model$.EVENTS = tapped;
+        }
+    },
+    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);
+    },
+};
+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('__'));
+    return names.map(name => ({
+        name,
+        trigger: BUILTIN_ACTIONS.has(name) ? 'builtin'
+            : intent.includes(name) ? 'intent'
+                : !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)) : [];
+}
+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 => ({ ...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 {
+            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) : [];
+        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: selectorsOf(r, options, diags),
+            diagnostics: diags.filter(d => d && d.component === r.name).map(slim),
+        };
+    });
+    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),
+    };
+}
+/** 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 */ }
+        }
+    };
+}
+
+/** Every runtime check in this entry. */
+const checks = [
+    wiringCheck,
+    stateCheck,
+    eventsCheck,
+    propsCheck,
+    collectionsCheck,
+    domCheck,
+    strictCheck,
+    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 uninstall = () => {
+        unregister.forEach(fn => fn());
+        uninstallHints();
+        uninstallInspect();
+        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();
+
+exports.RXJS_HINTS = RXJS_HINTS;
+exports.checkEventBus = checkEventBus;
+exports.checks = checks;
+exports.configureChecks = configureChecks;
+exports.configureStrict = configureStrict;
+exports.getCodeInfo = getCodeInfo;
+exports.inspect = inspect;
+exports.installChecks = installChecks;
+exports.isStrictEnabled = isStrictEnabled;
+exports.listCodes = listCodes;
+exports.resetChecks = resetChecks;
+//# sourceMappingURL=diagnostics.cjs.js.map