sygnal 6.2.0 → 6.3.0

package/dist/diagnostics.esm.js

@@ -247,6 +247,10 @@ 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',
+    // 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',
@@ -310,6 +314,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',
@@ -426,6 +453,10 @@ 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',
+    // 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',
@@ -466,6 +497,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',
@@ -497,6 +538,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];
@@ -3605,7 +3659,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.
  */
@@ -3678,6 +3733,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) {
@@ -3938,8 +4088,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');