sygnal 6.5.0 → 7.0.0

package/dist/diagnostics.esm.js

@@ -123,6 +123,9 @@ const CODE_TITLES = {
     SYG127: 'Behavior collision or unresolvable uses entry',
     SYG128: 'Duplicate control key',
     SYG129: "CHILD.select() of a component this one doesn't render",
+    // PLAN-10 X-1 (D512): graph-wide checks, static only (sygnal-check)
+    SYG170: 'Context field read with no provider',
+    SYG171: 'PARENT sink no parent reads',
     SYG112: 'Reply action has no model entry',
     SYG130: 'href() names no route or leaves out a param',
     SYG131: 'Route params the pattern does not use',
@@ -278,6 +281,8 @@ const CODE_TITLES = {
     SYG634: 'latest: true with a computed key',
     // PLAN-3 5-5 (D88)
     SYG635: 'Caching asked for without a queryCache',
+    // PLAN-11 U-1: progress requests (dev entry, fetch.ts)
+    SYG636: "progress that can't be reported as asked",
     // PLAN-4 GS-2: element commands (reported by the dev entry, checks/elementCommands.ts)
     SYG640: 'Element command target not found',
     SYG641: 'Unknown element command',
@@ -337,6 +342,9 @@ const CODE_TITLES = {
     // PLAN-9 X-2: static only (sygnal-check rules/syg253-catalog.js)
     SYG253: 'Misspelled catalog declaration key',
     SYG254: 'Catalog descriptions or options overlap',
+    SYG256: 'Output guard rejects the updated state',
+    SYG257: 'Output reads a field its action changed (7.0 timing audit)',
+    SYG454: 'State binding changed without a new component identity',
     // PLAN-9 H: chat client tools and ask (src/extra/ai/chat/behavior.ts, compose/ask.ts, compose/render.ts)
     SYG160: 'Result part rendered outside a card',
     SYG684: 'Client tool shadows an agent tool',
@@ -396,6 +404,9 @@ const DEV_CODE_SEVERITY = {
     SYG128: 'error',
     // PLAN-4 4-G2: static only (sygnal-check); listed so the entry knows its title
     SYG129: 'warn',
+    // PLAN-10 X-1: static only (sygnal-check)
+    SYG170: 'warn',
+    SYG171: 'warn',
     SYG221: 'error',
     // PLAN-4 GS-4 (state.ts)
     SYG222: 'warn',
@@ -444,6 +455,8 @@ const DEV_CODE_SEVERITY = {
     SYG634: 'info',
     // PLAN-3 5-5 (fetch.ts)
     SYG635: 'warn',
+    // PLAN-11 U-1 (fetch.ts)
+    SYG636: 'warn',
     // PLAN-4 GS-2 (checks/elementCommands.ts, through the core bridge; renderComponent too)
     SYG640: 'warn',
     SYG641: 'error',
@@ -560,6 +573,12 @@ const DEV_CODE_SEVERITY = {
     // PLAN-9 X-2: static only (sygnal-check); listed so the entry knows their titles
     SYG253: 'warn',
     SYG254: 'info',
+    // PLAN-12: static only; proven after-state output guard contradiction.
+    SYG256: 'warn',
+    // 7.0: the opt-in timing audit (checks/next.ts; configureTimingAudit)
+    SYG257: 'info',
+    // PLAN-12: static only for legacy (6.x) binding contracts. Sygnal 7 remounts known targets.
+    SYG454: 'warn',
 };
 function getCodeInfo(code) {
     const severity = CODE_SEVERITY[code];
@@ -1247,7 +1266,7 @@ onReset(() => {
 });
 /** 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 STATICS$2 = ['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)})`
@@ -1261,7 +1280,7 @@ function onControl(control, vnode) {
         vnodeControls.set(vnode, control);
     if (!staticsSeen.has(control)) {
         staticsSeen.add(control);
-        const given = STATICS$1.filter(s => control[s] != null);
+        const given = STATICS$2.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`,
@@ -2185,14 +2204,15 @@ const formsCheck = {
                 });
             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) {
+            // PLAN-11 F-3: with `request`, the form sends the submit itself and `submit` is optional
+            if (o.request ? o.submit !== undefined && (typeof o.submit != 'string' || !model.includes(o.submit) || clash) : 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`
+                    message: typeof o.submit != 'string' ? `${name}'s form '${key}' has no submit action and no request, 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' }) } }`,
+                        : `Give the form a request, form(schema, { values, request: { url: '/api/signup' } }) (it sends the valid submit itself), or 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 },
                 });
             }
@@ -2617,6 +2637,13 @@ const routerCheck = {
 const isStandardSchema = (schema) => !!schema && (typeof schema == 'object' || typeof schema == 'function') && typeof schema['~standard']?.validate == 'function';
 
 const IDEMPOTENT = /^(GET|HEAD)$/i;
+// PLAN-11 U-1: fetch() init options a progress request (XMLHttpRequest) can't honour
+const XHR_IGNORES = ['keepalive', 'priority', 'cache', 'redirect', 'integrity', 'mode', 'referrer', 'referrerPolicy', 'window', 'duplex'];
+const reportProgress = (component, sink, url, why, fix) => {
+    if (!once(`SYG636:${nameOf(component)}:${url}:${why}`))
+        return;
+    devReport('SYG636', { component, message: `${sink} ${url ? url + ' ' : ''}has progress, but ${why}`, fix, data: { sink, url } });
+};
 /** 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';
@@ -2640,7 +2667,7 @@ function checkOne(component, sink, req, where) {
         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();
+    const method = String(req.method || (req.json !== undefined || req.body !== undefined || req.multipart !== undefined ? 'POST' : 'GET')).toUpperCase();
     if ((req.cache === true || req.staleTime != null) && !IDEMPOTENT.test(method) && once(`SYG630:${name}:${method}:${url}`)) {
         devReport('SYG630', {
             component,
@@ -2651,6 +2678,17 @@ function checkOne(component, sink, req, where) {
     }
     if (req.cache === true || req.staleTime != null)
         reportNoCache(component, sink, req.cache === true ? 'cache: true' : 'staleTime', url);
+    if (req.progress) {
+        if (where.includes('.resources.'))
+            reportProgress(component, sink, url, 'resources report no progress (it is ignored)', 'Send the download as a request with progress and reply actions instead of a resource, or remove progress');
+        else if (req.batch)
+            reportProgress(component, sink, url, 'a batch request reports no progress (it is ignored)', 'Send the parts as separate requests with progress, or remove progress');
+        else {
+            const bad = XHR_IGNORES.filter(k => req.init && req.init[k] !== undefined);
+            if (bad.length)
+                reportProgress(component, sink, url, `it goes over XMLHttpRequest, which ignores init.${bad.join(', init.')}`, `Remove ${bad.join(', ')} from init for this request, or drop progress if the request needs ${bad.length > 1 ? 'them' : 'it'}`);
+        }
+    }
     if ('validate' in req && !isStandardSchema(req.validate) && once(`SYG631:${name}:${url}`)) {
         devReport('SYG631', {
             component,
@@ -3458,6 +3496,9 @@ const slim = (d) => {
         out.fix = d.fix;
     if (d.docsUrl)
         out.docsUrl = d.docsUrl;
+    // PLAN-10 P-1: when it was reported (runtime diagnostics are reported once per process)
+    if (typeof d.timestamp === 'number')
+        out.timestamp = d.timestamp;
     if (d.data !== undefined) {
         // keep it JSON-safe (data can hold errors, vnodes, ...)
         try {
@@ -3561,12 +3602,61 @@ function childrenOf(r, all) {
         const key = `${c.name}\u0000${via[c.kind]}`;
         const entry = out.get(key);
         if (entry)
-            entry.count = (entry.count || 1) + 1;
+            entry.count = entry.ids.push(c.id);
         else
-            out.set(key, { name: c.name, via: via[c.kind], count: 1 });
+            out.set(key, { name: c.name, via: via[c.kind], count: 1, ids: [c.id] });
     }
     return [...out.values()];
 }
+/** the statics sygnal-check reads (its STATIC_PROPS): a component function with none is view-only */
+const STATICS$1 = ['intent', 'model', 'initialState', 'isolatedState', 'context', 'calculated', 'connections', 'resources', 'route', 'head', 'uses', 'timers', 'persist', 'viewTransitions', 'browser', 'agent'];
+/** PLAN-10 D522: no statics and nothing the core added (renderComponent's test intent, a behavior's model) */
+function isViewOnly(c) {
+    const def = c && c.__next && c.__next.def;
+    if (!def || def.intent || (def.handlers && def.handlers.size) || def.initialState !== undefined)
+        return false;
+    const fn = def.view;
+    return !!fn && STATICS$1.every(k => fn[k] === undefined);
+}
+/** PLAN-10 P-2 (D544): the static key sygnal/vite's dev transform stamped on the component function */
+function stampedKey(c) {
+    const fn = c && c.__next && c.__next.def && c.__next.def.view;
+    const k = fn && fn.__sygnalKey;
+    return typeof k === 'string' ? k : undefined;
+}
+/** PLAN-10 D530: the context keys the instance's latest render read (InstanceView.reads); every key when it read them all */
+function contextReadsOf(c) {
+    const v = c && c.__next;
+    const reads = v && v.reads;
+    if (!reads)
+        return [];
+    const out = [...reads].filter(k => k !== '\u0000all');
+    if (reads.has('\u0000all')) {
+        try {
+            for (const k of Object.keys(v.context || {}))
+                if (!out.includes(k))
+                    out.push(k);
+        }
+        catch (_) { /* no context */ }
+    }
+    return out;
+}
+/** PLAN-10 D522: the app (run()) of each instance: the index of its root among the live roots, oldest first */
+function appsOf(all) {
+    const byId = new Map(all.map(r => [r.id, r]));
+    const roots = all.filter(r => r.parentId === null).sort((a, b) => Number(a.id) - Number(b.id));
+    const index = new Map(roots.map((r, i) => [r, i]));
+    const out = new Map();
+    for (const r of all) {
+        let top = r;
+        for (let n = 0; top && top.parentId !== null && n < 10000; n++)
+            top = byId.get(top.parentId);
+        const i = top && index.get(top);
+        if (i !== undefined)
+            out.set(r, i);
+    }
+    return out;
+}
 /** The app graph of the live component instances (see ./public.d.ts). */
 function inspect(options = {}) {
     // report SYG105 (info) for EVENTS types selected but never emitted so far
@@ -3591,21 +3681,28 @@ function inspect(options = {}) {
     const ids = options.ids && new Set(options.ids.map(String));
     const recs = ids ? all.filter(r => ids.has(r.id)) : all;
     const names = new Set(recs.map(r => r.name));
+    const apps = appsOf(all);
     const components = recs.map(r => {
         const c = r.instance;
         const calculated = c && c.calculated && typeof c.calculated === 'object' ? Object.keys(c.calculated) : [];
         const selectors = selectorsOf(r, options, diags);
         const controls = controlsOf(r, selectors);
+        const key = stampedKey(c);
         return {
             name: r.name,
             id: r.id,
+            ...(key ? { key } : {}),
             parentId: r.parentId,
             kind: r.kind,
+            ...(isViewOnly(c) ? { viewOnly: true } : {}),
+            ...(r.parentId === null ? { entry: true } : {}),
+            ...(apps.has(r) ? { app: apps.get(r) } : {}),
+            ...(c && c.__next && c.__next.shown === false ? { shown: false } : {}),
             actions: actionsOf(r),
             stateKeys: stateKeysOf(c, calculated),
             calculated,
             contextProvides: c && isPlainObject(c.context) ? Object.keys(c.context) : [],
-            contextConsumes: null,
+            contextConsumes: contextReadsOf(c),
             eventsEmitted: [...r.eventsEmitted],
             eventsSelected: [...r.eventsSelected],
             children: childrenOf(r, all),
@@ -3617,14 +3714,21 @@ function inspect(options = {}) {
     });
     const cache = cacheOf(recs) || {};
     const events = {};
-    const ev = (type) => events[type] || (events[type] = { emitters: [], selectors: [] });
+    // names once each (as before); PLAN-10 D522: every instance's id in emitterIds / selectorIds
+    const ev = (type) => events[type] || (events[type] = { emitters: [], selectors: [], emitterIds: [], selectorIds: [] });
     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);
+        for (const t of c.eventsEmitted) {
+            const e = ev(t);
+            add(e.emitters, c.name);
+            e.emitterIds.push(c.id);
+        }
+        for (const t of c.eventsSelected) {
+            const e = ev(t);
+            add(e.selectors, c.name);
+            e.selectorIds.push(c.id);
+        }
     }
     // emitted on the bus by something that isn't a listed component (e.g. a driver, a pruned component)
     if (!ids)
@@ -3685,6 +3789,52 @@ function installInspect() {
     };
 }
 
+/**
+ * The 7.0 timing audit (SYG257, info): since 7.0 a model entry's STATE runs first and every other
+ * sink gets the state it committed (6.x gave them the state from before the action). For code
+ * written for 6.x, this reports each output sink that reads a top-level state field its action's
+ * STATE changed: it gets the new value now. Fix: read `props.previousState.<field>` where the old
+ * value is meant; a read meant to see the new value needs nothing. Opt-in, because in 7.0-native
+ * code reading the new value is the intent. Turn it on with any of:
+ *   - configureTimingAudit(true)                 (this entry)
+ *   - renderComponent(C, { timingAudit: true })  (tests)
+ *   - sygnal({ diagnostics: { timingAudit: true } })  (sygnal/vite, dev)
+ *   - globalThis.__SYGNAL_TIMING_AUDIT__ = true
+ * The flag lives on the core bridge (shared by every copy of this entry and renderComponent).
+ * Mechanism: the dev hook layer's wrapHandler (checks/next.ts) wraps each non-STATE handler and
+ * gives it the state through a Proxy that notes reads of changed top-level fields. Top-level
+ * fields only (a nested change shows as its top-level field changing); once per component name,
+ * action, sink and field. Nothing in production builds.
+ */
+/** Turn the timing audit on (true), off (false), or back to the default (globalThis.__SYGNAL_TIMING_AUDIT__). */
+function configureTimingAudit(on) {
+    const core = bridge();
+    if (core)
+        core.timingAudit = on;
+}
+/** Whether the timing audit is on. */
+function isTimingAuditEnabled() {
+    const flag = bridge()?.timingAudit;
+    return flag === undefined ? globalThis.__SYGNAL_TIMING_AUDIT__ === true : flag === true;
+}
+/** handler `h` of `f`'s action `type`, sink `sink`, audited (f: the checks' instance facade) */
+const audited = (f, type, sink, h) => (s, d, nx, p, ...r) => {
+    const was = p?.previousState;
+    if (!isTimingAuditEnabled() || !was || was === s || !s || typeof s != 'object' || typeof was != 'object' || Array.isArray(s))
+        return h(s, d, nx, p, ...r);
+    const view = new Proxy(s, { get(t, k, rcv) {
+            if (typeof k == 'string' && k in was && was[k] !== t[k] && once(`SYG257:${f.name}:${type}:${sink}:${k}`))
+                devReport('SYG257', {
+                    component: f,
+                    message: `${f.name}'s '${type}' ${sink} read state.${k}, which the same action's STATE changed: since 7.0 it gets the new value (6.x gave it the old one)`,
+                    fix: `If it meant the value from before the action, read props.previousState.${k} (the 4th argument); if it meant the new value, nothing to change`,
+                    data: { action: type, sink, field: k },
+                });
+            return Reflect.get(t, k, rcv);
+        } });
+    return h(view, d, nx, p, ...r);
+};
+
 /**
  * PLAN-4.6 R4: the dev entry's checks on the next component core (src/core/).
  *
@@ -4197,6 +4347,9 @@ function nextHooks(_api) {
         onAction(iv, a) { log.onAction(iv, a); },
         wrapHandler(iv, type, sink, fn) {
             let h = log.wrapHandler(iv, type, sink, fn) || fn;
+            // 7.0 timing audit (SYG257, opt-in; checks/timingAudit.ts): checked per call, so turning it on later counts
+            if (on() && sink != 'STATE' && typeof h == 'function')
+                h = audited(fac(iv), type, sink, h);
             // SYG222: the STATE reducers, wrapped (today the check rewrote the instance's model)
             if (on() && sink == 'STATE' && typeof fn == 'function')
                 h = watchMutation(fac(iv), type, h);
@@ -4411,5 +4564,5 @@ function resetChecks() {
 }
 installChecks();
 
-export { RXJS_HINTS, checkEventBus, checks, configureChecks, configureStrict, getCodeInfo, inspect, installChecks, isStrictEnabled, listCodes, resetChecks };
+export { RXJS_HINTS, checkEventBus, checks, configureChecks, configureStrict, configureTimingAudit, getCodeInfo, inspect, installChecks, isStrictEnabled, isTimingAuditEnabled, listCodes, resetChecks };
 //# sourceMappingURL=diagnostics.esm.js.map