@kernlang/review 2.0.0 → 3.0.0

package/dist/rules/kern-source.js

@@ -0,0 +1,726 @@
+/**
+ * .kern source review rules that operate on flattened IRNode[] plus file path.
+ *
+ * These are distinct from ground-layer lint rules because they need file-aware
+ * spans and scope-sensitive analysis over handler/expr bodies.
+ */
+import { countTokens } from '@kernlang/core';
+import { SyntaxKind } from 'ts-morph';
+import { createInMemoryProject } from '../inferrer.js';
+import { createFingerprint } from '../types.js';
+const SCOPE_NODE_TYPES = new Set([
+    'screen', 'hook', 'provider', 'fn', 'callback', 'memo', 'effect',
+    'route', 'server', 'service', 'method', 'singleton', 'constructor',
+    'middleware', 'cli', 'command', 'test', 'describe', 'it',
+    // Template node types + CLI
+    'arrow-fn', 'swr-hook', 'zustand-store', 'zustand-selector', 'module',
+    'cli',
+]);
+const DIRECT_BINDING_NODE_TYPES = new Set([
+    'state', 'const', 'fn', 'derive', 'import', 'ref', 'context',
+    'callback', 'memo', 'effect', 'middleware', 'hook', 'method',
+    'arg', 'flag',
+    // Template node types that declare a name binding
+    'arrow-fn', 'swr-hook', 'zustand-store', 'zustand-selector',
+]);
+const TYPE_POSITION_KINDS = new Set([
+    SyntaxKind.TypeReference,
+    SyntaxKind.ExpressionWithTypeArguments,
+    SyntaxKind.TypeAliasDeclaration,
+    SyntaxKind.InterfaceDeclaration,
+    SyntaxKind.TypeParameter,
+    SyntaxKind.TypeLiteral,
+    SyntaxKind.UnionType,
+    SyntaxKind.IntersectionType,
+    SyntaxKind.LiteralType,
+    SyntaxKind.ArrayType,
+    SyntaxKind.TupleType,
+    SyntaxKind.TypeOperator,
+    SyntaxKind.ParenthesizedType,
+    SyntaxKind.FunctionType,
+    SyntaxKind.ConstructorType,
+    SyntaxKind.ConditionalType,
+    SyntaxKind.IndexedAccessType,
+    SyntaxKind.MappedType,
+    SyntaxKind.ImportType,
+    SyntaxKind.TypePredicate,
+    SyntaxKind.ThisType,
+    SyntaxKind.QualifiedName,
+    SyntaxKind.HeritageClause,
+]);
+const SAFE_STRING_MEMBERS = new Set([
+    'at', 'charAt', 'charCodeAt', 'codePointAt', 'concat', 'endsWith',
+    'includes', 'indexOf', 'lastIndexOf', 'length', 'localeCompare',
+    'match', 'matchAll', 'normalize', 'padEnd', 'padStart', 'repeat',
+    'replace', 'replaceAll', 'search', 'slice', 'split', 'startsWith',
+    'substring', 'toLocaleLowerCase', 'toLocaleUpperCase', 'toLowerCase',
+    'toString', 'toUpperCase', 'trim', 'trimEnd', 'trimStart', 'valueOf',
+]);
+const AMBIENT_NAMES = new Set([
+    // JS globals
+    'Array', 'AbortController', 'Boolean', 'Buffer', 'Date', 'Error', 'Headers',
+    'JSON', 'Map', 'Math', 'Number', 'Object', 'Promise', 'RegExp', 'Request',
+    'Response', 'Set', 'String', 'URL', 'URLSearchParams', 'console', 'crypto',
+    'clearInterval', 'clearTimeout', 'document', 'fetch', 'globalThis', 'location',
+    'navigator', 'process', 'setInterval', 'setTimeout', 'window',
+    'undefined', 'NaN', 'Infinity', 'Symbol', 'WeakMap', 'WeakSet', 'Proxy',
+    'Reflect', 'queueMicrotask', 'structuredClone', 'atob', 'btoa',
+    // HTTP handler context (injected by framework)
+    'req', 'res', 'ctx', 'next', 'params', 'query', 'body', 'headers',
+    'event', 'env', 'emit', 'send', 'status',
+    // State/dispatch (React/KERN runtime)
+    'state', 'dispatch', 'get', 'set', 'props', 'self', 'this',
+    // Common external service references (injected via DI or app context)
+    'db', 'redis', 'cache', 'store', 'config', 'logger', 'app',
+    // CLI context (common in KERN CLI examples)
+    'opts', 'args', 'options', 'argv',
+    // SWR/hook context (data comes from framework)
+    'data', 'error', 'isLoading', 'mutate', 'isValidating',
+]);
+const EXTERNAL_SIGNAL_RE = /\b(fetch|axios|db|redis|stripe|openai|supabase|client|api|provider|registry|http|https)\b|await\s+[A-Za-z_$]/;
+const UNCERTAIN_SIGNAL_RE = /\b(guess|heuristic|fallback|bestEffort|approx|uncertain|unknown|maybe)\b|Math\.random|Date\.now/;
+function props(node) {
+    return node.props || {};
+}
+function loc(node) {
+    return { line: node.loc?.line || 1, col: node.loc?.col || 1 };
+}
+function finding(ruleId, severity, category, message, filePath, node, extra) {
+    const { line, col } = loc(node);
+    return {
+        source: 'kern',
+        ruleId,
+        severity,
+        category,
+        message,
+        primarySpan: { file: filePath, startLine: line, startCol: col, endLine: line, endCol: col },
+        fingerprint: createFingerprint(ruleId, line, col),
+        ...extra,
+    };
+}
+function capitalize(text) {
+    return text.charAt(0).toUpperCase() + text.slice(1);
+}
+function buildParentMap(nodes) {
+    const parentMap = new Map();
+    for (const node of nodes) {
+        if (!parentMap.has(node))
+            parentMap.set(node, undefined);
+    }
+    for (const node of nodes) {
+        for (const child of node.children || []) {
+            if (parentMap.has(child))
+                parentMap.set(child, node);
+        }
+    }
+    return parentMap;
+}
+function isScopeNode(node) {
+    return SCOPE_NODE_TYPES.has(node.type);
+}
+function splitTopLevel(text, separator) {
+    const parts = [];
+    let current = '';
+    let depth = 0;
+    let inQuote = false;
+    for (let i = 0; i < text.length; i++) {
+        const ch = text[i];
+        if (ch === '"' || ch === '\'') {
+            inQuote = !inQuote;
+            current += ch;
+            continue;
+        }
+        if (!inQuote && (ch === '<' || ch === '(' || ch === '{' || ch === '[')) {
+            depth++;
+        }
+        else if (!inQuote && depth > 0 && (ch === '>' || ch === ')' || ch === '}' || ch === ']')) {
+            depth--;
+        }
+        if (!inQuote && depth === 0 && ch === separator) {
+            if (current.trim())
+                parts.push(current.trim());
+            current = '';
+            continue;
+        }
+        current += ch;
+    }
+    if (current.trim())
+        parts.push(current.trim());
+    return parts;
+}
+function findTopLevelChar(text, wanted) {
+    let depth = 0;
+    let inQuote = false;
+    for (let i = 0; i < text.length; i++) {
+        const ch = text[i];
+        if (ch === '"' || ch === '\'') {
+            inQuote = !inQuote;
+            continue;
+        }
+        if (!inQuote && (ch === '<' || ch === '(' || ch === '{' || ch === '['))
+            depth++;
+        else if (!inQuote && depth > 0 && (ch === '>' || ch === ')' || ch === '}' || ch === ']'))
+            depth--;
+        else if (!inQuote && depth === 0 && ch === wanted)
+            return i;
+    }
+    return -1;
+}
+function parseParamBindings(raw) {
+    if (typeof raw !== 'string' || raw.trim() === '')
+        return [];
+    const bindings = [];
+    for (const part of splitTopLevel(raw, ',')) {
+        const colonIdx = findTopLevelChar(part, ':');
+        const eqIdx = findTopLevelChar(part, '=');
+        const rawName = colonIdx >= 0 ? part.slice(0, colonIdx).trim() : (eqIdx >= 0 ? part.slice(0, eqIdx).trim() : part.trim());
+        if (!/^[A-Za-z_$][\w$]*$/.test(rawName))
+            continue;
+        let typeName;
+        if (colonIdx >= 0) {
+            const rawType = (eqIdx >= 0 ? part.slice(colonIdx + 1, eqIdx) : part.slice(colonIdx + 1)).trim();
+            const directAlias = getDirectTypeAlias(rawType);
+            if (directAlias)
+                typeName = directAlias;
+        }
+        bindings.push({ name: rawName, typeName });
+    }
+    return bindings;
+}
+function getDirectTypeAlias(typeText) {
+    if (!typeText)
+        return undefined;
+    const compact = typeText.replace(/\s+/g, '');
+    if (!compact)
+        return undefined;
+    if (compact.includes('<') || compact.includes('[') || compact.includes('{') || compact.includes('&'))
+        return undefined;
+    const parts = compact.split('|').filter(part => part !== 'null' && part !== 'undefined');
+    if (parts.length !== 1)
+        return undefined;
+    return /^[A-Za-z_$][\w$]*$/.test(parts[0]) ? parts[0] : undefined;
+}
+function getUnionLiteralKind(variants) {
+    const trimmed = variants.map(variant => variant.trim()).filter(Boolean);
+    if (trimmed.length === 0)
+        return 'mixed';
+    if (trimmed.every(variant => variant === 'true' || variant === 'false'))
+        return 'boolean';
+    if (trimmed.every(variant => /^-?\d+(?:\.\d+)?$/.test(variant)))
+        return 'number';
+    if (trimmed.every(variant => /^".*"$/.test(variant) || /^'.*'$/.test(variant) || /^[A-Za-z_][A-Za-z0-9_-]*$/.test(variant))) {
+        return 'string';
+    }
+    return 'mixed';
+}
+function buildUnionAliasMap(nodes) {
+    const unions = new Map();
+    for (const node of nodes) {
+        if (node.type !== 'type')
+            continue;
+        const p = props(node);
+        if (typeof p.name !== 'string' || typeof p.values !== 'string')
+            continue;
+        const variants = p.values.split('|').map(part => part.trim()).filter(Boolean);
+        if (variants.length < 2)
+            continue;
+        unions.set(p.name, {
+            node,
+            variants,
+            literalKind: getUnionLiteralKind(variants),
+        });
+    }
+    return unions;
+}
+function addBinding(target, name, info) {
+    if (!name || target.has(name))
+        return;
+    target.set(name, info);
+}
+function addBindingsFromScopeNode(scopeNode, target) {
+    const p = props(scopeNode);
+    for (const binding of parseParamBindings(p.params)) {
+        addBinding(target, binding.name, { kind: 'param', node: scopeNode, typeName: binding.typeName });
+    }
+    if (DIRECT_BINDING_NODE_TYPES.has(scopeNode.type) && typeof p.name === 'string') {
+        addBinding(target, p.name, {
+            kind: scopeNode.type,
+            node: scopeNode,
+            typeName: typeof p.type === 'string' ? getDirectTypeAlias(p.type) : undefined,
+        });
+        if (scopeNode.type === 'state') {
+            addBinding(target, `set${capitalize(p.name)}`, { kind: 'state-setter', node: scopeNode });
+        }
+    }
+    for (const child of scopeNode.children || []) {
+        const cp = props(child);
+        if (child.type === 'params' && Array.isArray(cp.items)) {
+            for (const item of cp.items) {
+                if (typeof item.name !== 'string')
+                    continue;
+                addBinding(target, item.name, {
+                    kind: 'param',
+                    node: child,
+                    typeName: typeof item.type === 'string' ? getDirectTypeAlias(item.type) : undefined,
+                });
+            }
+            continue;
+        }
+        if (!DIRECT_BINDING_NODE_TYPES.has(child.type))
+            continue;
+        // Import nodes use 'names' (comma-separated) instead of 'name'
+        if (child.type === 'import' && typeof cp.names === 'string') {
+            for (const importedName of cp.names.split(',').map((s) => s.trim()).filter(Boolean)) {
+                addBinding(target, importedName, { kind: 'import', node: child });
+            }
+            continue;
+        }
+        if (typeof cp.name !== 'string')
+            continue;
+        addBinding(target, cp.name, {
+            kind: child.type,
+            node: child,
+            typeName: typeof cp.type === 'string' ? getDirectTypeAlias(cp.type) : undefined,
+        });
+        if (child.type === 'state') {
+            addBinding(target, `set${capitalize(cp.name)}`, { kind: 'state-setter', node: child });
+        }
+    }
+}
+function collectVisibleBindings(node, parentMap) {
+    const bindings = new Map();
+    let current = parentMap.get(node);
+    while (current) {
+        if (isScopeNode(current) || parentMap.get(current) === undefined) {
+            addBindingsFromScopeNode(current, bindings);
+        }
+        current = parentMap.get(current);
+    }
+    return bindings;
+}
+function createSnippetAnalysis(project, code, key, mode) {
+    const filePath = `__kern_${key.replace(/[^A-Za-z0-9_]/g, '_')}_${Math.random().toString(36).slice(2)}.tsx`;
+    const wrapped = mode === 'expr'
+        ? `async function __kern__() { return (${code}); }\n`
+        : `async function __kern__() {\n${code}\n}\n`;
+    const sourceFile = project.createSourceFile(filePath, wrapped, { overwrite: true });
+    const localBindings = collectLocalBindings(sourceFile);
+    const referenceNames = new Set();
+    const propertyAccesses = [];
+    const elementAccesses = [];
+    const objectDestructures = [];
+    for (const identifier of sourceFile.getDescendantsOfKind(SyntaxKind.Identifier)) {
+        const name = identifier.getText();
+        if (!/^[A-Za-z_$][\w$]*$/.test(name))
+            continue;
+        if (AMBIENT_NAMES.has(name))
+            continue;
+        if (isDeclarationIdentifier(identifier))
+            continue;
+        if (isTypeOnlyIdentifier(identifier))
+            continue;
+        if (isNonReferencePropertyName(identifier))
+            continue;
+        referenceNames.add(name);
+    }
+    for (const access of sourceFile.getDescendantsOfKind(SyntaxKind.PropertyAccessExpression)) {
+        const expr = access.getExpression();
+        if (expr.getKind() !== SyntaxKind.Identifier)
+            continue;
+        const baseName = expr.getText();
+        if (!/^[A-Za-z_$][\w$]*$/.test(baseName))
+            continue;
+        propertyAccesses.push({ baseName, propertyName: access.getName() });
+    }
+    for (const access of sourceFile.getDescendantsOfKind(SyntaxKind.ElementAccessExpression)) {
+        const expr = access.getExpression();
+        if (expr.getKind() !== SyntaxKind.Identifier)
+            continue;
+        const baseName = expr.getText();
+        if (!/^[A-Za-z_$][\w$]*$/.test(baseName))
+            continue;
+        const arg = access.getArgumentExpression();
+        let propertyName;
+        if (arg && arg.getKind() === SyntaxKind.StringLiteral) {
+            propertyName = arg.getText().slice(1, -1);
+        }
+        elementAccesses.push({ baseName, propertyName });
+    }
+    for (const decl of sourceFile.getDescendantsOfKind(SyntaxKind.VariableDeclaration)) {
+        const nameNode = decl.getNameNode();
+        if (nameNode.getKind() !== SyntaxKind.ObjectBindingPattern)
+            continue;
+        const init = decl.getInitializer();
+        if (!init || init.getKind() !== SyntaxKind.Identifier)
+            continue;
+        objectDestructures.push({ sourceName: init.getText() });
+    }
+    sourceFile.forget();
+    return { localBindings, referenceNames, propertyAccesses, elementAccesses, objectDestructures };
+}
+function collectLocalBindings(sourceFile) {
+    const bindings = new Set();
+    for (const decl of sourceFile.getDescendantsOfKind(SyntaxKind.VariableDeclaration)) {
+        addBindingNamesFromNode(decl.getNameNode(), bindings);
+    }
+    for (const param of sourceFile.getDescendantsOfKind(SyntaxKind.Parameter)) {
+        addBindingNamesFromNode(param.getNameNode(), bindings);
+    }
+    for (const fn of sourceFile.getDescendantsOfKind(SyntaxKind.FunctionDeclaration)) {
+        const name = fn.getName();
+        if (name)
+            bindings.add(name);
+    }
+    for (const cls of sourceFile.getDescendantsOfKind(SyntaxKind.ClassDeclaration)) {
+        const name = cls.getName();
+        if (name)
+            bindings.add(name);
+    }
+    for (const catchClause of sourceFile.getDescendantsOfKind(SyntaxKind.CatchClause)) {
+        const variable = catchClause.getVariableDeclaration();
+        if (variable)
+            addBindingNamesFromNode(variable.getNameNode(), bindings);
+    }
+    return bindings;
+}
+function addBindingNamesFromNode(node, bindings) {
+    if (node.getKind() === SyntaxKind.Identifier) {
+        bindings.add(node.getText());
+        return;
+    }
+    if (node.getKind() === SyntaxKind.ObjectBindingPattern || node.getKind() === SyntaxKind.ArrayBindingPattern) {
+        for (const descendant of node.getDescendantsOfKind(SyntaxKind.BindingElement)) {
+            addBindingNamesFromNode(descendant.getNameNode(), bindings);
+        }
+    }
+}
+function isDeclarationIdentifier(identifier) {
+    const parent = identifier.getParent();
+    if (!parent)
+        return false;
+    if (parent.getKind() === SyntaxKind.BindingElement && parent.getNameNode() === identifier) {
+        return true;
+    }
+    if (parent.getKind() === SyntaxKind.Parameter && parent.getNameNode() === identifier) {
+        return true;
+    }
+    if (parent.getKind() === SyntaxKind.VariableDeclaration && parent.getNameNode() === identifier) {
+        return true;
+    }
+    const parentAny = parent;
+    return parentAny.getNameNode?.() === identifier;
+}
+function isNonReferencePropertyName(identifier) {
+    const parent = identifier.getParent();
+    if (!parent)
+        return false;
+    switch (parent.getKind()) {
+        case SyntaxKind.PropertyAccessExpression:
+            return parent.getNameNode() === identifier;
+        case SyntaxKind.PropertyAssignment:
+            return parent.getNameNode() === identifier;
+        case SyntaxKind.PropertyDeclaration:
+        case SyntaxKind.PropertySignature:
+        case SyntaxKind.MethodDeclaration:
+        case SyntaxKind.GetAccessor:
+        case SyntaxKind.SetAccessor:
+            return parent.getNameNode() === identifier;
+        case SyntaxKind.BindingElement:
+            return parent.getPropertyNameNode() === identifier;
+        default:
+            return false;
+    }
+}
+function isTypeOnlyIdentifier(identifier) {
+    let current = identifier.getParent();
+    while (current) {
+        if (TYPE_POSITION_KINDS.has(current.getKind()))
+            return true;
+        if (current.getKind() === SyntaxKind.ExpressionStatement ||
+            current.getKind() === SyntaxKind.ReturnStatement ||
+            current.getKind() === SyntaxKind.VariableDeclaration ||
+            current.getKind() === SyntaxKind.CallExpression ||
+            current.getKind() === SyntaxKind.BinaryExpression ||
+            current.getKind() === SyntaxKind.IfStatement) {
+            return false;
+        }
+        current = current.getParent();
+    }
+    return false;
+}
+function getCodeProp(node, key = 'code') {
+    const value = props(node)[key];
+    return typeof value === 'string' && value.trim() !== '' ? value : undefined;
+}
+function getExprCode(node, key = 'expr') {
+    const value = props(node)[key];
+    if (!value || typeof value !== 'object')
+        return undefined;
+    const expr = value;
+    return typeof expr.code === 'string' && expr.code.trim() !== '' ? expr.code : undefined;
+}
+function walkSubtree(node, visit) {
+    visit(node);
+    for (const child of node.children || []) {
+        walkSubtree(child, visit);
+    }
+}
+function stringifyPropValue(value) {
+    if (value === null || value === undefined)
+        return '';
+    if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean')
+        return String(value);
+    if (Array.isArray(value))
+        return value.map(stringifyPropValue).join(' ');
+    if (typeof value === 'object') {
+        const entries = Object.entries(value);
+        return entries.map(([key, nested]) => `${key} ${stringifyPropValue(nested)}`).join(' ');
+    }
+    return String(value);
+}
+function countStructuralTokens(node) {
+    const parts = [node.type];
+    for (const [key, value] of Object.entries(props(node))) {
+        if (key === 'code')
+            continue;
+        parts.push(key);
+        parts.push(stringifyPropValue(value));
+    }
+    return countTokens(parts.join(' '));
+}
+function describeNode(node, parentMap) {
+    const p = props(node);
+    if (typeof p.name === 'string' && p.name)
+        return p.name;
+    const parent = parentMap.get(node);
+    const parentName = parent ? props(parent).name : undefined;
+    if (typeof parentName === 'string' && parentName)
+        return `${parentName}.${node.type}`;
+    return `${node.type}@L${loc(node).line}`;
+}
+export const undefinedReference = (nodes, filePath) => {
+    const findings = [];
+    const parentMap = buildParentMap(nodes);
+    const project = createInMemoryProject();
+    for (const node of nodes) {
+        if (node.type !== 'handler')
+            continue;
+        const code = getCodeProp(node);
+        if (!code)
+            continue;
+        const visibleBindings = collectVisibleBindings(node, parentMap);
+        const analysis = createSnippetAnalysis(project, code, `undef_${loc(node).line}`, 'block');
+        const unresolved = [...analysis.referenceNames]
+            .filter(name => !analysis.localBindings.has(name))
+            .filter(name => !visibleBindings.has(name))
+            .filter(name => !AMBIENT_NAMES.has(name))
+            .sort();
+        if (unresolved.length === 0)
+            continue;
+        findings.push(finding('undefined-reference', 'error', 'bug', `Handler references name(s) that are not declared in visible KERN scope: ${unresolved.join(', ')}`, filePath, node, {
+            suggestion: 'Declare the value as state/const/fn/derive, add it as a param, or qualify it through an existing scoped object.',
+        }));
+    }
+    return findings;
+};
+export const typeModelMismatch = (nodes, filePath) => {
+    const findings = [];
+    const parentMap = buildParentMap(nodes);
+    const unionAliases = buildUnionAliasMap(nodes);
+    if (unionAliases.size === 0)
+        return findings;
+    const project = createInMemoryProject();
+    for (const node of nodes) {
+        if (node.type !== 'handler')
+            continue;
+        const code = getCodeProp(node);
+        if (!code)
+            continue;
+        const visibleBindings = collectVisibleBindings(node, parentMap);
+        const unionBindings = new Map();
+        for (const [name, binding] of visibleBindings) {
+            if (!binding.typeName)
+                continue;
+            const union = unionAliases.get(binding.typeName);
+            if (!union)
+                continue;
+            unionBindings.set(name, { alias: binding.typeName, union, sourceNode: binding.node });
+        }
+        if (unionBindings.size === 0)
+            continue;
+        const analysis = createSnippetAnalysis(project, code, `type_mismatch_${loc(node).line}`, 'block');
+        const mismatches = new Map();
+        for (const access of analysis.propertyAccesses) {
+            const binding = unionBindings.get(access.baseName);
+            if (!binding)
+                continue;
+            if (binding.union.literalKind === 'string' && SAFE_STRING_MEMBERS.has(access.propertyName))
+                continue;
+            const key = `${access.baseName}:${binding.alias}`;
+            if (!mismatches.has(key))
+                mismatches.set(key, new Set());
+            mismatches.get(key).add(access.propertyName);
+        }
+        for (const access of analysis.elementAccesses) {
+            const binding = unionBindings.get(access.baseName);
+            if (!binding)
+                continue;
+            const key = `${access.baseName}:${binding.alias}`;
+            if (!mismatches.has(key))
+                mismatches.set(key, new Set());
+            mismatches.get(key).add(access.propertyName || '[computed]');
+        }
+        for (const destructure of analysis.objectDestructures) {
+            const binding = unionBindings.get(destructure.sourceName);
+            if (!binding)
+                continue;
+            const key = `${destructure.sourceName}:${binding.alias}`;
+            if (!mismatches.has(key))
+                mismatches.set(key, new Set());
+            mismatches.get(key).add('{...}');
+        }
+        for (const [key, members] of mismatches) {
+            const [bindingName, alias] = key.split(':');
+            const union = unionAliases.get(alias);
+            const relatedInfo = union != null
+                ? {
+                    relatedSpans: [{
+                            file: filePath,
+                            startLine: loc(union.node).line,
+                            startCol: loc(union.node).col,
+                            endLine: loc(union.node).line,
+                            endCol: loc(union.node).col,
+                        }],
+                    suggestion: `Use '${bindingName}' as a literal value, or change '${alias}' to an interface/union with object variants if field access is intended.`,
+                }
+                : undefined;
+            findings.push(finding('type-model-mismatch', 'warning', 'type', `Literal-union type '${alias}' is used like an object in handler code: ${bindingName}.${[...members].join(', ')}`, filePath, node, relatedInfo));
+        }
+    }
+    return findings;
+};
+export const unusedState = (nodes, filePath) => {
+    const findings = [];
+    const parentMap = buildParentMap(nodes);
+    const project = createInMemoryProject();
+    for (const node of nodes) {
+        if (node.type !== 'state')
+            continue;
+        const p = props(node);
+        if (typeof p.name !== 'string' || !p.name)
+            continue;
+        const scopeRoot = parentMap.get(node);
+        if (!scopeRoot)
+            continue;
+        // Skip states inside machine nodes — they're used by transitions (from=/to= props)
+        if (scopeRoot.type === 'machine')
+            continue;
+        const stateName = p.name;
+        const setterName = `set${capitalize(stateName)}`;
+        let used = false;
+        walkSubtree(scopeRoot, current => {
+            if (used || current === node)
+                return;
+            // Check bind= attribute (e.g., input bind=query)
+            const cp = props(current);
+            if (typeof cp.bind === 'string' && cp.bind === stateName) {
+                used = true;
+                return;
+            }
+            // Check value/initial/expr props for direct state references (e.g., value={{ query }})
+            for (const val of Object.values(cp)) {
+                if (typeof val === 'string' && new RegExp(`\\b${stateName}\\b`).test(val)) {
+                    used = true;
+                    return;
+                }
+            }
+            const blockCode = current.type === 'handler' || current.type === 'logic' || current.type === 'body'
+                ? getCodeProp(current)
+                : undefined;
+            if (blockCode) {
+                const analysis = createSnippetAnalysis(project, blockCode, `state_${stateName}_${loc(current).line}`, 'block');
+                const readsState = analysis.referenceNames.has(stateName) && !analysis.localBindings.has(stateName);
+                const usesSetter = analysis.referenceNames.has(setterName) && !analysis.localBindings.has(setterName);
+                if (readsState || usesSetter)
+                    used = true;
+                return;
+            }
+            const exprCode = current.type === 'guard' || current.type === 'derive'
+                ? getExprCode(current)
+                : undefined;
+            if (!exprCode)
+                return;
+            const analysis = createSnippetAnalysis(project, exprCode, `state_expr_${stateName}_${loc(current).line}`, 'expr');
+            const readsState = analysis.referenceNames.has(stateName) && !analysis.localBindings.has(stateName);
+            if (readsState)
+                used = true;
+        });
+        if (used)
+            continue;
+        findings.push(finding('unused-state', 'warning', 'structure', `State '${p.name}' is declared but never referenced in handlers, derives, guards, or logic within its scope`, filePath, node, {
+            suggestion: `Remove '${p.name}' or wire it into the surrounding KERN logic.`,
+        }));
+    }
+    return findings;
+};
+export const handlerHeavy = (nodes, filePath) => {
+    const handlers = nodes.filter(node => node.type === 'handler' && getCodeProp(node));
+    if (handlers.length === 0)
+        return [];
+    let handlerTokens = 0;
+    let structureTokens = 0;
+    for (const node of nodes) {
+        structureTokens += countStructuralTokens(node);
+        if (node.type === 'handler') {
+            const code = getCodeProp(node);
+            if (code)
+                handlerTokens += countTokens(code);
+        }
+    }
+    const totalTokens = handlerTokens + structureTokens;
+    if (totalTokens === 0)
+        return [];
+    const ratio = handlerTokens / totalTokens;
+    if (ratio <= 0.6)
+        return [];
+    const anchor = handlers[0];
+    return [finding('handler-heavy', 'warning', 'structure', `Embedded handler code accounts for ${(ratio * 100).toFixed(0)}% of file tokens (${handlerTokens}/${totalTokens}); this file is mostly inline JS with a thin KERN wrapper`, filePath, anchor, {
+            suggestion: 'Promote repeated handler logic into native KERN nodes such as derive, guard, collect, respond, or named fn blocks.',
+        })];
+};
+export const missingConfidence = (nodes, filePath) => {
+    if (nodes.some(node => props(node).confidence !== undefined))
+        return [];
+    if (nodes.length === 0)
+        return [];
+    const parentMap = buildParentMap(nodes);
+    const candidates = new Set();
+    for (const node of nodes) {
+        const code = getCodeProp(node) || getExprCode(node);
+        if (!code)
+            continue;
+        if (!EXTERNAL_SIGNAL_RE.test(code) && !UNCERTAIN_SIGNAL_RE.test(code))
+            continue;
+        candidates.add(describeNode(node.type === 'handler' ? (parentMap.get(node) || node) : node, parentMap));
+        if (candidates.size >= 3)
+            break;
+    }
+    const anchor = nodes[0];
+    const suffix = candidates.size > 0
+        ? ` Candidate nodes: ${[...candidates].join(', ')}.`
+        : '';
+    return [finding('missing-confidence', 'info', 'pattern', `No confidence annotations found in this .kern file. Add confidence props to external-service calls or uncertain logic.${suffix}`, filePath, anchor, {
+            suggestion: 'Annotate critical nodes with confidence=0.x, confidence=from:name, or confidence=min:a,b to make trust levels explicit.',
+        })];
+};
+export function lintKernSourceIR(nodes, filePath, rules = KERN_SOURCE_RULES) {
+    return rules.flatMap(rule => rule(nodes, filePath));
+}
+export const KERN_SOURCE_RULES = [
+    undefinedReference,
+    typeModelMismatch,
+    unusedState,
+    handlerHeavy,
+    missingConfidence,
+];
+//# sourceMappingURL=kern-source.js.map