sygnal 6.6.0 → 7.0.0

package/dist/diagnostics.cjs.js

@@ -301,6 +301,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',
@@ -360,6 +362,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',
@@ -470,6 +475,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',
@@ -586,6 +593,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];
@@ -2211,14 +2224,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 },
                 });
             }
@@ -2643,6 +2657,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';
@@ -2666,7 +2687,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,
@@ -2677,6 +2698,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,
@@ -3777,6 +3809,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/).
  *
@@ -4289,6 +4367,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);
@@ -4508,10 +4589,12 @@ exports.checkEventBus = checkEventBus;
 exports.checks = checks;
 exports.configureChecks = configureChecks;
 exports.configureStrict = configureStrict;
+exports.configureTimingAudit = configureTimingAudit;
 exports.getCodeInfo = getCodeInfo;
 exports.inspect = inspect;
 exports.installChecks = installChecks;
 exports.isStrictEnabled = isStrictEnabled;
+exports.isTimingAuditEnabled = isTimingAuditEnabled;
 exports.listCodes = listCodes;
 exports.resetChecks = resetChecks;
 //# sourceMappingURL=diagnostics.cjs.js.map