sygnal 6.2.0 → 6.4.0

package/dist/diagnostics.cjs.js

@@ -267,6 +267,13 @@ const CODE_TITLES = {
     SYG423: 'Context change skipped a view whose output it changes',
     SYG424: 'Duplicate Collection item id',
     SYG425: 'isolatedState slice lacks initialState keys',
+    // PLAN-9 (D471): checks/next.ts; dev entry and sygnal-check
+    SYG426: 'Deprecated lowercase marker tag',
+    // checks/next.ts and sygnal-check: a component reference that is not a function (an import of
+    // a name the module doesn't export is undefined under Vitest)
+    SYG427: 'CHILD.select() of something that is not a component',
+    // PLAN-9 (D470): checks/next.ts; dev entry
+    SYG453: 'Two children with the same identity share one instance',
     SYG601: "Retired in 6.0: Missing or invalid sources",
     SYG602: 'Intent is not a function',
     SYG603: 'Intent returned an invalid value',
@@ -330,6 +337,29 @@ const CODE_TITLES = {
     // PLAN-6 A-2: experimentalExposeWebMcp (src/extra/ai/webmcp.ts; dev)
     SYG674: 'WebMCP not available',
     SYG676: 'WebMCP registerTool rejected',
+    // ---- PLAN-9 compose (A: src/extra/ai/compose/; dev, reported with the severity passed) ----
+    SYG161: 'Catalog container render is a component with a model',
+    SYG162: 'Catalog part with neither component nor render',
+    SYG250: 'Layout names an unknown part or slot',
+    SYG251: 'Invalid param value in a layout',
+    SYG252: 'Record param from() does not return an array of { value }',
+    SYG450: 'Catalog in names an unknown container or slot',
+    SYG451: 'Composed has no catalog or from is not a composition',
+    SYG452: 'Layout lists a node key twice',
+    SYG681: 'Compose backend option problem',
+    // PLAN-9 B-1/B-2: compose.decisions() (src/extra/ai/compose/decisions.ts; explicit severities)
+    SYG680: 'Part is LLM-only under a decision backend',
+    SYG682: 'Decision model answered outside the criteria',
+    // PLAN-9 B-3: compose.llm() (src/extra/ai/compose/llm.ts; the compose status becomes 'error')
+    SYG683: 'LLM layout invalid after repair',
+    // PLAN-9 X-2: static only (sygnal-check rules/syg253-catalog.js)
+    SYG253: 'Misspelled catalog declaration key',
+    SYG254: 'Catalog descriptions or options overlap',
+    // 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',
+    SYG685: 'Answer for a tool call that is not open',
+    SYG686: 'Ask catalog without a result part',
     // 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',
@@ -446,6 +476,12 @@ const DEV_CODE_SEVERITY = {
     SYG423: 'warn',
     SYG424: 'warn',
     SYG425: 'warn',
+    // PLAN-9 (checks/next.ts): D471 a lowercase <collection> / <switchable> tag (deprecated in 6.3.0)
+    SYG426: 'warn',
+    // checks/next.ts: CHILD.select(undefined), usually a missing export
+    SYG427: 'error',
+    // PLAN-9 (checks/next.ts): D470 key identity, two children with one identity
+    SYG453: 'warn',
     SYG612: 'error',
     // PLAN-4 D131 (element.ts, through the core bridge; a console warning in dev with diagnostics off)
     SYG644: 'warn',
@@ -486,6 +522,16 @@ const DEV_CODE_SEVERITY = {
     // PLAN-6 A-2 (experimentalExposeWebMcp reports them with an explicit severity)
     SYG674: 'info',
     SYG676: 'warn',
+    // PLAN-9 B-1/B-2 (compose.decisions() reports them with an explicit severity)
+    SYG680: 'info',
+    SYG682: 'warn',
+    // PLAN-9 B-3 (compose.llm)
+    SYG683: 'error',
+    // PLAN-9 H (chat client tools and ask; reported with the severity passed)
+    SYG160: 'warn',
+    SYG684: 'warn',
+    SYG685: 'warn',
+    SYG686: 'warn',
     // PLAN-5 V-1: VirtualCollection (checks/virtual.ts, through the core bridge)
     SYG430: 'warn',
     SYG431: 'warn',
@@ -517,6 +563,19 @@ const DEV_CODE_SEVERITY = {
     SYG153: 'warn',
     SYG730: 'warn',
     SYG731: 'warn',
+    // ---- PLAN-9 compose (A: src/extra/ai/compose/, reported with the severity passed, dev) ----
+    SYG161: 'error',
+    SYG162: 'error',
+    SYG250: 'warn',
+    SYG251: 'warn',
+    SYG252: 'warn',
+    SYG450: 'warn',
+    SYG451: 'warn',
+    SYG452: 'warn',
+    SYG681: 'error',
+    // PLAN-9 X-2: static only (sygnal-check); listed so the entry knows their titles
+    SYG253: 'warn',
+    SYG254: 'info',
 };
 function getCodeInfo(code) {
     const severity = CODE_SEVERITY[code];
@@ -737,11 +796,20 @@ const underTest = (c) => {
     const dom = c?.sources?.[c.DOMSourceName || 'DOM'];
     return !!dom && typeof dom == 'object' && '_hub' in dom;
 };
-// G-620: an LLM / chat sink gets the chat driver's fix, not makeFetchDriver's
-const driverFix = (sink) => `Pass a driver named ${sink} to run(): ` + (/^(LLM|CHAT|AI|ASSISTANT)$/.test(sink)
-    ? `run(App, { ${sink}: makeChatDriver({ transport: openResponses({ baseURL: 'http://localhost:11434/v1', model: 'llama3.2' }) }) }) (from 'sygnal/ai'; uiMessageStream('/api/chat') for an AI SDK server)`
-    : `run(App, { ${sink}: makeFetchDriver() }) for HTTP, or driverFromAsync(fn) / your own driver`) +
-    `. Check the spelling against the drivers you pass`;
+// G-620: the usual driver for a known sink name (an LLM / chat sink gets the chat driver's fix,
+// SW the service worker's), the generic text for any other name
+const DRIVER_FOR = [
+    [/^(LLM|CHAT|AI|ASSISTANT)$/, (s) => `run(App, { ${s}: makeChatDriver({ transport: openResponses({ baseURL: 'http://localhost:11434/v1', model: 'llama3.2' }) }) }) (from 'sygnal/ai'; uiMessageStream('/api/chat') for an AI SDK server)`],
+    [/^(SW|SERVICE_WORKER)$/, (s) => `run(App, { ${s}: makeServiceWorkerDriver('/sw.js', { enabled: import.meta.env.PROD }) }) (enabled: false keeps the driver, with no service worker, on a dev server)`],
+    [/^(HTTP|API|FETCH)$/, (s) => `run(App, { ${s}: makeFetchDriver() })`],
+    [/^(WS|SOCKET)$/, (s) => `run(App, { ${s}: makeSocketDriver() })`],
+];
+const driverFix = (sink) => {
+    const known = DRIVER_FOR.find(([re]) => re.test(sink));
+    return `Pass a driver named ${sink} to run(): ` +
+        (known ? known[1](sink) : `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) {
@@ -1290,6 +1358,10 @@ onReset(() => {
 });
 const unref = (t) => { if (t && typeof t.unref === 'function')
     t.unref(); return t; };
+/**
+ * The view's source, plus the words sygnal/vite registered for the component (its module's and
+ * its relative imports' string literals: markup a view helper draws), when it did
+ */
 function viewSource(component) {
     const view = component && component.view;
     if (typeof view !== 'function')
@@ -1302,6 +1374,9 @@ function viewSource(component) {
         catch (_) {
             src = '';
         }
+        const registered = globalThis.__SYGNAL_VIEW_TOKENS__?.get?.(view);
+        if (typeof registered == 'string')
+            src += '\n' + registered;
         viewTokens.set(view, src);
     }
     return src;
@@ -2946,7 +3021,8 @@ const persistCheck = {
         const o = p.options, init = view.initialState;
         if (!o || !init || typeof init != 'object')
             return;
-        const keys = Object.keys(init);
+        // a behavior's slice (`uses = { chat: chat() }`) is a state key too
+        const keys = [...Object.keys(init), ...Object.keys(view.uses || {})];
         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}`))
@@ -3625,7 +3701,8 @@ function installInspect() {
  *   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).
+ *   guide), SYG453 (PLAN-9, D470: two children with one identity share one instance), SYG426
+ *   (PLAN-9, D471: a lowercase <collection> / <switchable> tag, deprecated in 6.3.0).
  *
  * Only while diagnostics are on (the checks' own rule); production builds never load this.
  */
@@ -3659,6 +3736,18 @@ function removed(component, name, anchor, detail) {
         data: { form: anchor, guide: `${MIGRATE}#${anchor}`, ...(detail ? { detail } : {}) },
     });
 }
+/** SYG427: CHILD.select(x) with no component (an import of a name the module doesn't export) */
+function notComponent(f, x) {
+    if (!once(`SYG427:${f.name}`))
+        return;
+    const got = x === null ? 'null' : typeof x == 'object' ? 'an object' : String(x);
+    devReport('SYG427', {
+        component: f.name,
+        message: `${f.name}'s intent calls CHILD.select(${got}): that is not a component, so it never emits`,
+        fix: "Pass the child component itself, and check its import: a name its module doesn't export is undefined (Vitest runs on; the browser fails to link the module). Export it: export function Child() { … }",
+        data: { got },
+    });
+}
 /** 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)
@@ -3698,6 +3787,101 @@ function removedTags(f, v, depth = 0) {
         for (const k of kids)
             removedTags(f, k, depth + 1);
 }
+/**
+ * PLAN-9 SYG453 (D470): two children of one view with the same identity (the same component and
+ * `key`, else `id`; `sel::key` in the core) are one instance, rendered in both places. The core
+ * doesn't look (0 production bytes): in the owner's injected vnode that instance's output, a
+ * scoped root (`data.isolate` in the real DOM driver, a `___<scope>` class in the mock DOM), is
+ * the same object twice. Its name and key come from the child whose DOM source has that scope.
+ */
+const scopeOfVnode = (n) => {
+    const iso = n.data?.isolate;
+    if (Array.isArray(iso))
+        return iso.length ? iso[iso.length - 1]?.scope : undefined;
+    const m = typeof n.sel == 'string' && /\.___([^.]+)/.exec(n.sel);
+    return m ? m[1] : undefined;
+};
+const scopeOfSource = (dom) => {
+    const ns = dom?.namespace;
+    if (Array.isArray(ns))
+        return ns[ns.length - 1]?.scope;
+    const p = dom?._path;
+    const m = Array.isArray(p) && /^\.___(.+)$/.exec(String(p[p.length - 1]));
+    return m ? m[1] : undefined;
+};
+function sharedIdentity(iv, v) {
+    const seen = new Set(), dup = new Set();
+    const walk = (n, d) => {
+        if (!n || typeof n != 'object' || d > 300)
+            return;
+        const sc = scopeOfVnode(n);
+        if (sc !== undefined) {
+            if (seen.has(n)) {
+                dup.add(sc);
+                return;
+            }
+            seen.add(n);
+        }
+        const kids = n.children;
+        if (Array.isArray(kids))
+            for (const k of kids)
+                walk(k, d + 1);
+    };
+    walk(v, 0);
+    if (!dup.size)
+        return;
+    const owner = iv.name;
+    for (const sc of dup) {
+        let child;
+        try {
+            child = iv.children().find((c) => scopeOfSource(c.sources?.DOM) === sc);
+        }
+        catch (_) { /* ignore */ }
+        const name = child ? child.name : 'a child component';
+        // the identity's own part of the child's uid (the owner's uid + '-' + its key, id or path)
+        const key = child && typeof child.uid == 'string' && child.uid.startsWith(iv.uid + '-') ? child.uid.slice(iv.uid.length + 1) : undefined;
+        if (!once(`SYG453:${owner}:${name}:${key ?? sc}`))
+            continue;
+        devReport('SYG453', {
+            component: owner,
+            message: `${owner} renders ${child ? `<${name}>` : name} in two places with the same identity${key !== undefined ? ` (key or id ${JSON.stringify(key)})` : ''}, so both places show one instance: it has one state, and the second tag's props replace the first's`,
+            fix: `Give each <${child ? name : 'Child'}> a different key (or id) among its parent's children, e.g. key={item.id}; a key on a component is its identity`,
+            data: { child: child ? name : undefined, key },
+        });
+    }
+}
+/**
+ * PLAN-9 SYG426 (D471): the lowercase host tags, `<collection>` / `<switchable>` (JSX string tags,
+ * or `h('collection')`), deprecated in 6.3.0; the next major removes them (and registers the hosts
+ * on first use, as Portal). The core doesn't look (0 production bytes): the instance's template
+ * keeps a host marker after reconcile (only `pres` markers are rewritten), and the imported
+ * components' markers carry their function in `data.m`, a string tag's don't. The template is
+ * the raw instance's (`iv.i`: the InstanceView's own field, a dev entry of the same build reads it;
+ * the vnode onRender gets has the hosts' output injected in their place). Once per tag.
+ */
+const HOST_TAGS = { collection: 'Collection', switchable: 'Switchable' };
+function lowercaseTags(iv) {
+    const raw = iv.i;
+    if (!raw?.kids?.size || !raw.tmpl)
+        return;
+    const walk = (n, d) => {
+        if (!n || typeof n != 'object' || n.$p || d > 300)
+            return;
+        const name = typeof n.sel == 'string' && !n.data?.m && HOST_TAGS[n.sel];
+        if (name && once(`SYG426:${n.sel}`))
+            devReport('SYG426', {
+                component: iv.name,
+                message: `${iv.name} renders the lowercase <${n.sel}> tag, which is deprecated since Sygnal 6.3.0 and will be removed in the next major (it will then render an unknown <${n.sel}> element)`,
+                fix: `import { ${name} } from 'sygnal' and write <${name} …> (sygnal-check --fix does it)`,
+                data: { tag: n.sel, component: name },
+            });
+        const kids = n.children;
+        if (Array.isArray(kids))
+            for (const k of kids)
+                walk(k, d + 1);
+    };
+    walk(raw.tmpl, 0);
+}
 /** the instance fields the checks read from today's Component instances */
 class Facade {
     constructor(__next) {
@@ -3947,8 +4131,13 @@ function nextHooks(_api) {
                     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); } };
+                    return { ...v, select: (x, ...r) => {
+                            if (typeof x == 'string')
+                                removed(f, f.name, 'child-select-name', `CHILD.select('${x}')`);
+                            else if (typeof x != 'function')
+                                notComponent(f, x);
+                            return v.select(x, ...r);
+                        } };
                 },
             });
         },
@@ -3958,8 +4147,19 @@ function nextHooks(_api) {
         onRender(iv, vnode) {
             const f = fac(iv);
             H.onRender(f, vnode);
-            if (on())
-                removedTags(f, vnode);
+            if (!on())
+                return;
+            removedTags(f, vnode);
+            try {
+                lowercaseTags(iv);
+            }
+            catch (_) { /* a check never breaks the app */ }
+            // SYG453: only a view with children can render one twice
+            if (iv.children().length)
+                try {
+                    sharedIdentity(iv, vnode);
+                }
+                catch (_) { /* a check never breaks the app */ }
         },
         onReducer(iv, type, prev, next) {
             H.onReducer(fac(iv), type, prev, next, 'STATE');