norn-cli 2.2.2 → 2.4.0

package/out/diagnosticProvider.js

@@ -0,0 +1,2554 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DiagnosticProvider = void 0;
+const vscode = __importStar(require("vscode"));
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
+const parser_1 = require("./parser");
+const sequenceRunner_1 = require("./sequenceRunner");
+const assertionRunner_1 = require("./assertionRunner");
+const environmentProvider_1 = require("./environmentProvider");
+const nornapiParser_1 = require("./nornapiParser");
+const jsonFileReader_1 = require("./jsonFileReader");
+const environmentParser_1 = require("./environmentParser");
+const crypto_1 = require("./secrets/crypto");
+const nornSqlParser_1 = require("./nornSqlParser");
+const sqlConfig_1 = require("./sqlConfig");
+const formUrlEncoded_1 = require("./formUrlEncoded");
+const mcpConfig_1 = require("./mcpConfig");
+const nornConfig_1 = require("./nornConfig");
+const stringUtils_1 = require("./stringUtils");
+const requestValidation_1 = require("./requestValidation");
+function pushNornDiagnostic(diagnostics, range, message, severity, code) {
+    const diagnostic = new vscode.Diagnostic(range, message, severity);
+    diagnostic.source = 'Norn';
+    if (code) {
+        diagnostic.code = code;
+    }
+    diagnostics.push(diagnostic);
+}
+function createTokenRange(lines, lineNumber, token) {
+    const line = lines[lineNumber] ?? '';
+    const startCol = Math.max(0, line.indexOf(token));
+    return new vscode.Range(new vscode.Position(lineNumber, startCol), new vscode.Position(lineNumber, startCol + token.length));
+}
+function parseNornenvTemplateReference(rawReference) {
+    const match = rawReference.trim().match(/^(?:\$env\.)?([a-zA-Z_][a-zA-Z0-9_]*)$/);
+    return match?.[1];
+}
+function getNornenvTemplateDeclarationForDiagnostics(line, lineNumber, section) {
+    const connectionMatch = line.match(/^(\s*)(?:secret\s+)?connectionString\s+([a-zA-Z_][a-zA-Z0-9_]*)\s*=\s*(.*)$/i);
+    if (connectionMatch) {
+        return {
+            name: `${connectionMatch[2]}_connectionString`,
+            sectionKind: section?.kind,
+            sectionName: section?.name,
+            lineNumber,
+            value: connectionMatch[3],
+            valueStart: connectionMatch[0].length - connectionMatch[3].length
+        };
+    }
+    const variableMatch = line.match(/^(\s*)(?:secret|var)\s+([a-zA-Z_][a-zA-Z0-9_]*)\s*=\s*(.*)$/i);
+    if (variableMatch) {
+        return {
+            name: variableMatch[2],
+            sectionKind: section?.kind,
+            sectionName: section?.name,
+            lineNumber,
+            value: variableMatch[3],
+            valueStart: variableMatch[0].length - variableMatch[3].length
+        };
+    }
+    return undefined;
+}
+function parseNornenvSectionForDiagnostics(line, lineNumber) {
+    const match = line.trim().match(/^\[(env|template):([a-zA-Z_][a-zA-Z0-9_-]*)(?:\s+extends\s+([^\]]+))?\]\s*$/i);
+    if (!match) {
+        return undefined;
+    }
+    const parents = (match[3] ?? '')
+        .split(',')
+        .map(parent => parent.trim())
+        .filter(parent => /^[a-zA-Z_][a-zA-Z0-9_-]*$/.test(parent));
+    return {
+        kind: match[1].toLowerCase(),
+        name: match[2],
+        parents,
+        lineNumber
+    };
+}
+function getNornenvParentReferencesForDiagnostics(line, section) {
+    const extendsMatch = line.match(/\bextends\b/i);
+    const closeBracket = line.lastIndexOf(']');
+    if (!extendsMatch || closeBracket < 0 || extendsMatch.index === undefined) {
+        return [];
+    }
+    const clauseStart = extendsMatch.index + extendsMatch[0].length;
+    const clause = line.slice(clauseStart, closeBracket);
+    const refs = [];
+    const tokenRegex = /[a-zA-Z_][a-zA-Z0-9_-]*/g;
+    for (const match of clause.matchAll(tokenRegex)) {
+        if (match.index === undefined) {
+            continue;
+        }
+        refs.push({
+            section,
+            name: match[0],
+            start: clauseStart + match.index,
+            end: clauseStart + match.index + match[0].length
+        });
+    }
+    return refs;
+}
+function levenshteinDistance(left, right) {
+    const a = left.toLowerCase();
+    const b = right.toLowerCase();
+    const previous = Array.from({ length: b.length + 1 }, (_, index) => index);
+    const current = Array.from({ length: b.length + 1 }, () => 0);
+    for (let i = 1; i <= a.length; i++) {
+        current[0] = i;
+        for (let j = 1; j <= b.length; j++) {
+            const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+            current[j] = Math.min(current[j - 1] + 1, previous[j] + 1, previous[j - 1] + cost);
+        }
+        for (let j = 0; j <= b.length; j++) {
+            previous[j] = current[j];
+        }
+    }
+    return previous[b.length];
+}
+function findClosestNornenvName(name, candidates) {
+    let bestName;
+    let bestDistance = Number.POSITIVE_INFINITY;
+    for (const candidate of candidates) {
+        const distance = levenshteinDistance(name, candidate);
+        if (distance < bestDistance) {
+            bestDistance = distance;
+            bestName = candidate;
+        }
+    }
+    const maxDistance = name.length <= 5 ? 1 : 2;
+    return bestDistance <= maxDistance ? bestName : undefined;
+}
+function buildDeclaredNornenvNameSet(config) {
+    const names = new Set(Object.keys(config.common));
+    for (const template of config.templates) {
+        for (const name of Object.keys(template.variables)) {
+            names.add(name);
+        }
+    }
+    for (const env of config.environments) {
+        for (const name of Object.keys(env.variables)) {
+            names.add(name);
+        }
+    }
+    return names;
+}
+function buildAllowedNornenvReferenceNames(declaration, config) {
+    const names = new Set(Object.keys(config.common));
+    if (!declaration.sectionName) {
+        for (const name of buildDeclaredNornenvNameSet(config)) {
+            names.add(name);
+        }
+        return names;
+    }
+    for (const name of (0, environmentParser_1.collectAncestorVariableNames)(declaration.sectionName, config)) {
+        names.add(name);
+    }
+    return names;
+}
+/**
+ * Extracts variables defined within a specific sequence, including:
+ * - var statements
+ * - var x = run Sequence (capture from returned sequences)
+ * - Response captures (var x = $1.body)
+ * - Sequence parameters (from the sequence declaration)
+ */
+function getSequenceLocalVariables(sequenceContent, parameters) {
+    const vars = new Set();
+    // Add sequence parameters as local variables
+    if (parameters) {
+        for (const param of parameters) {
+            vars.add(param.name);
+        }
+    }
+    const lines = sequenceContent.split('\n');
+    for (const line of lines) {
+        const trimmed = line.trim();
+        // Match any var assignment
+        const varMatch = trimmed.match(/^var\s+([a-zA-Z_][a-zA-Z0-9_]*)\s*=/);
+        if (varMatch) {
+            vars.add(varMatch[1]);
+        }
+    }
+    return vars;
+}
+/**
+ * Check if a line is a comment (starts with #)
+ */
+function isCommentLine(line) {
+    return line.trim().startsWith('#');
+}
+function getEnvScopedBaseName(pathPart) {
+    const trimmed = pathPart.replace(/^\./, '');
+    const match = trimmed.match(/^([a-zA-Z_][a-zA-Z0-9_]*)/);
+    return match ? match[1] : undefined;
+}
+function getAllDeclaredEnvironmentVariableNames(sourceFilePath) {
+    const envFilePath = (0, environmentProvider_1.findEnvFileFromPath)(sourceFilePath);
+    if (!envFilePath || !fs.existsSync(envFilePath)) {
+        return new Set();
+    }
+    try {
+        const content = fs.readFileSync(envFilePath, 'utf-8');
+        const config = (0, environmentParser_1.parseEnvFile)(content, envFilePath);
+        const resolved = (0, environmentParser_1.resolveNornenvImports)(config, path.dirname(envFilePath), envFilePath, filePath => fs.readFileSync(filePath, 'utf-8'));
+        const names = new Set(Object.keys(resolved.config.common));
+        for (const template of resolved.config.templates) {
+            for (const name of Object.keys(template.variables)) {
+                names.add(name);
+            }
+        }
+        for (const env of resolved.config.environments) {
+            for (const name of (0, environmentParser_1.resolveEffectiveEnvVariableDetails)(env.name, resolved.config).keys()) {
+                names.add(name);
+            }
+        }
+        return names;
+    }
+    catch {
+        return new Set();
+    }
+}
+function getNornapiVariableDiagnosticContext(sourceFilePath) {
+    const activeEnvironment = (0, environmentProvider_1.getActiveEnvironment)(sourceFilePath);
+    const envFilePath = (0, environmentProvider_1.findEnvFileFromPath)(sourceFilePath);
+    const activeVariableNames = new Set(Object.keys((0, environmentProvider_1.getEnvironmentVariables)(sourceFilePath)));
+    const allEnvironmentVariableNames = getAllDeclaredEnvironmentVariableNames(sourceFilePath);
+    const validationVariableNames = activeEnvironment ? activeVariableNames : allEnvironmentVariableNames;
+    return {
+        activeVariableNames,
+        allEnvironmentVariableNames,
+        validationVariableNames,
+        hasEnvFile: Boolean(envFilePath),
+        activeEnvironment,
+        availableEnvironments: (0, environmentProvider_1.getAvailableEnvironments)(sourceFilePath)
+    };
+}
+function buildNornapiVariableDiagnosticMessage(varName, envScoped, context) {
+    if (envScoped) {
+        if (!context.hasEnvFile) {
+            return `Undefined environment variable: '${varName}'. Add a .nornenv file that defines it.`;
+        }
+        if (!context.activeEnvironment && context.availableEnvironments.length > 0) {
+            return `Undefined environment variable: '${varName}'. Select an environment that defines it or add it to the common .nornenv variables.`;
+        }
+        if (context.activeEnvironment) {
+            return `Undefined environment variable: '${varName}' in active environment '${context.activeEnvironment}'.`;
+        }
+        return `Undefined environment variable: '${varName}' in .nornenv.`;
+    }
+    if (!context.hasEnvFile) {
+        return `Undefined endpoint variable: '${varName}'. Add a .nornenv file that defines it.`;
+    }
+    if (context.activeEnvironment && context.allEnvironmentVariableNames.has(varName)) {
+        return `Endpoint variable '${varName}' is not defined for active environment '${context.activeEnvironment}'.`;
+    }
+    return `Undefined endpoint variable: '${varName}'. Define it in .nornenv or use {${varName}} if it should be an endpoint parameter.`;
+}
+function addNornapiPlaceholderDiagnostics(diagnostics, lineNumber, lineText, searchText, searchStartCol, context, includeUnscoped) {
+    for (const reference of (0, requestValidation_1.findPlaceholderReferences)(searchText)) {
+        if (/^\$\d+$/.test(reference.name)) {
+            continue;
+        }
+        const envScoped = reference.name === '$env';
+        if (!envScoped && !includeUnscoped) {
+            continue;
+        }
+        const varName = envScoped ? getEnvScopedBaseName(reference.pathPart) : reference.name;
+        if (!varName) {
+            continue;
+        }
+        const availableNames = envScoped ? context.activeVariableNames : context.validationVariableNames;
+        if (availableNames.has(varName)) {
+            continue;
+        }
+        const startCol = Math.max(0, searchStartCol + reference.index);
+        const endCol = Math.min(lineText.length, startCol + reference.text.length);
+        const range = new vscode.Range(new vscode.Position(lineNumber, startCol), new vscode.Position(lineNumber, endCol));
+        const code = envScoped ? 'undefined-env-variable' : 'undefined-endpoint-variable';
+        if (diagnostics.some(d => d.code === code &&
+            d.range.start.line === range.start.line &&
+            d.range.start.character === range.start.character &&
+            d.range.end.character === range.end.character)) {
+            continue;
+        }
+        pushNornDiagnostic(diagnostics, range, buildNornapiVariableDiagnosticMessage(varName, envScoped, context), vscode.DiagnosticSeverity.Error, code);
+    }
+}
+function isHttpRequestStart(line) {
+    return /^(?:var\s+[a-zA-Z_][a-zA-Z0-9_]*\s*=\s*)?(GET|POST|PUT|DELETE|PATCH|HEAD|OPTIONS)\s+/i.test(line.trim());
+}
+function isRequestBodyBoundary(line) {
+    const trimmed = line.trim();
+    if (!trimmed) {
+        return false;
+    }
+    return trimmed.startsWith('###') ||
+        trimmed.startsWith('@') ||
+        isHttpRequestStart(trimmed) ||
+        /^\[/.test(trimmed) ||
+        /^import\s+/i.test(trimmed) ||
+        /^(?:test\s+)?sequence\s+/i.test(trimmed) ||
+        /^end\s+sequence$/i.test(trimmed) ||
+        /^(?:end\s+if|endif)\b/i.test(trimmed) ||
+        /^var\s+/i.test(trimmed) ||
+        /^(?:var\s+[a-zA-Z_][a-zA-Z0-9_]*\s*=\s*)?run\s+/i.test(trimmed) ||
+        /^assert\s+/i.test(trimmed) ||
+        /^print\s+/i.test(trimmed) ||
+        /^if\s+/i.test(trimmed) ||
+        /^wait\s+/i.test(trimmed) ||
+        /^foreach\s+/i.test(trimmed) ||
+        /^return\s+/i.test(trimmed);
+}
+function countChar(value, char) {
+    let count = 0;
+    for (let i = 0; i < value.length; i++) {
+        if (value[i] === char) {
+            count++;
+        }
+    }
+    return count;
+}
+function looksLikeJsonPropertyLine(line) {
+    return /^"[^"\\]*(?:\\.[^"\\]*)*"\s*:\s*.+$/.test(line.trim());
+}
+function isLikelyJsonBodyLine(line) {
+    const trimmed = line.trim();
+    if (!trimmed) {
+        return false;
+    }
+    return trimmed.startsWith('{') ||
+        trimmed.startsWith('}') ||
+        trimmed.startsWith('[') ||
+        trimmed.startsWith(']') ||
+        trimmed.startsWith('"') ||
+        looksLikeJsonPropertyLine(trimmed) ||
+        /^,/.test(trimmed);
+}
+function isLikelyFormBodyLine(line) {
+    const trimmed = line.trim();
+    if (!trimmed) {
+        return false;
+    }
+    if (/^[A-Za-z0-9_.-]+\s*=\s*.+$/.test(trimmed)) {
+        return true;
+    }
+    // Colon lines may be headers or form body. Treat as body-like to avoid false positives.
+    if (/^[A-Za-z0-9_.-]+\s*:\s*.+$/.test(trimmed)) {
+        return true;
+    }
+    return false;
+}
+function isLikelyRequestBodyValueLine(line) {
+    const trimmed = line.trim();
+    if (!trimmed) {
+        return false;
+    }
+    if (isLikelyJsonBodyLine(trimmed) || isLikelyFormBodyLine(trimmed)) {
+        return true;
+    }
+    // Primitive JSON values can be valid standalone request bodies.
+    if (/^(true|false|null)$/i.test(trimmed) || /^-?\d+(?:\.\d+)?$/.test(trimmed)) {
+        return true;
+    }
+    // Allow a variable/path reference used as the body (e.g. "payload" or "payload.items[0]").
+    if (/^[a-zA-Z_][a-zA-Z0-9_]*(?:\.[a-zA-Z_][a-zA-Z0-9_]*|\[\d+\])*$/.test(trimmed)) {
+        return true;
+    }
+    // Placeholder-only line can also be a valid body.
+    if (/^\{\{[^\r\n}]+\}\}$/.test(trimmed)) {
+        return true;
+    }
+    // Header group line in a request block ("Json") should not break body-context detection.
+    if (/^[A-Z][a-zA-Z0-9_]*$/.test(trimmed)) {
+        return true;
+    }
+    return false;
+}
+function isInsideRequestBlock(lines, lineIndex) {
+    for (let j = lineIndex - 1; j >= 0; j--) {
+        const rawLine = lines[j];
+        if (isCommentLine(rawLine)) {
+            continue;
+        }
+        const trimmed = (0, stringUtils_1.stripInlineComment)(rawLine).trim();
+        if (!trimmed) {
+            continue;
+        }
+        if (isHttpRequestStart(trimmed)) {
+            return true;
+        }
+        if (isRequestBodyBoundary(trimmed)) {
+            return false;
+        }
+        if (isLikelyRequestBodyValueLine(trimmed)) {
+            continue;
+        }
+        return false;
+    }
+    return false;
+}
+function isKnownNornCommandOrStructureStart(line) {
+    const trimmed = line.trim();
+    if (!trimmed) {
+        return true;
+    }
+    if (trimmed.startsWith('###') ||
+        trimmed.startsWith('@') ||
+        /^\[.*\]$/.test(trimmed) ||
+        /^import\s+/i.test(trimmed) ||
+        /^(?:test\s+)?sequence\s+/i.test(trimmed) ||
+        /^end\s+sequence$/i.test(trimmed) ||
+        /^(?:end\s+if|endif)$/i.test(trimmed) ||
+        /^if\s+/i.test(trimmed) ||
+        /^wait\s+/i.test(trimmed) ||
+        /^assert\s+/i.test(trimmed) ||
+        /^print\s+/i.test(trimmed) ||
+        /^return(?:\s+.+)?$/i.test(trimmed) ||
+        /^foreach\s+/i.test(trimmed) ||
+        /^var\s+/i.test(trimmed) ||
+        /^(?:var\s+[a-zA-Z_][a-zA-Z0-9_]*\s*=\s*)?run\s+/i.test(trimmed) ||
+        (0, jsonFileReader_1.parsePropertyAssignment)(trimmed) !== null ||
+        isHttpRequestStart(trimmed)) {
+        return true;
+    }
+    // Request block continuations / body-ish lines
+    if (/^[A-Za-z0-9\-_]+\s*:\s*.+$/.test(trimmed) || // header lines
+        isLikelyJsonBodyLine(trimmed) ||
+        isLikelyFormBodyLine(trimmed) ||
+        /^[A-Z][a-zA-Z0-9_]*$/.test(trimmed)) { // possible header-group line
+        return true;
+    }
+    return false;
+}
+function isLikelyPartialCommand(line) {
+    const trimmed = line.trim().toLowerCase();
+    if (!trimmed) {
+        return false;
+    }
+    const partials = [
+        'g', 'ge', 'p', 'po', 'pos', 'pu', 'pat', 'del', 'hea', 'opt',
+        'v', 'va', 'var',
+        'a', 'as', 'ass', 'asse', 'asser',
+        'assert',
+        'pr', 'pri', 'prin', 'print',
+        'r', 'ru', 'run',
+        'i', 'im', 'imp', 'impo', 'impor', 'import',
+        'ret', 'retu', 'retur', 'return',
+        'seq', 'sequ', 'seque', 'sequen', 'sequenc', 'sequence',
+        'te', 'tes',
+        'w', 'wa', 'wai', 'wait',
+        'if',
+        'en', 'end', 'end ', 'endif', 'end if',
+        'test', 'test sequence'
+    ];
+    return partials.includes(trimmed);
+}
+function isSingleEditOrTransposeAway(a, b) {
+    if (a === b) {
+        return false;
+    }
+    if (Math.abs(a.length - b.length) > 1) {
+        return false;
+    }
+    // Transposition check (same length)
+    if (a.length === b.length) {
+        const mismatches = [];
+        for (let i = 0; i < a.length; i++) {
+            if (a[i] !== b[i]) {
+                mismatches.push(i);
+                if (mismatches.length > 2) {
+                    break;
+                }
+            }
+        }
+        if (mismatches.length === 2) {
+            const [i, j] = mismatches;
+            if (j === i + 1 && a[i] === b[j] && a[j] === b[i]) {
+                return true;
+            }
+        }
+    }
+    // One-edit (insert/delete/replace)
+    let i = 0;
+    let j = 0;
+    let edits = 0;
+    while (i < a.length && j < b.length) {
+        if (a[i] === b[j]) {
+            i++;
+            j++;
+            continue;
+        }
+        edits++;
+        if (edits > 1) {
+            return false;
+        }
+        if (a.length > b.length) {
+            i++;
+        }
+        else if (b.length > a.length) {
+            j++;
+        }
+        else {
+            i++;
+            j++;
+        }
+    }
+    if (i < a.length || j < b.length) {
+        edits++;
+    }
+    return edits === 1;
+}
+function suggestClosestKeyword(token, candidates) {
+    const lower = token.toLowerCase();
+    return candidates.find(candidate => isSingleEditOrTransposeAway(lower, candidate.toLowerCase()));
+}
+function splitRequestUrlAndTail(afterMethod) {
+    const trimmed = afterMethod.trim();
+    if (!trimmed) {
+        return { urlToken: undefined, tail: '' };
+    }
+    if (trimmed.startsWith('"') || trimmed.startsWith("'")) {
+        const quote = trimmed[0];
+        let escaped = false;
+        for (let i = 1; i < trimmed.length; i++) {
+            const ch = trimmed[i];
+            if (escaped) {
+                escaped = false;
+                continue;
+            }
+            if (ch === '\\') {
+                escaped = true;
+                continue;
+            }
+            if (ch === quote) {
+                return {
+                    urlToken: trimmed.slice(0, i + 1),
+                    tail: trimmed.slice(i + 1).trim()
+                };
+            }
+        }
+        // Unclosed quote - likely still typing.
+        return { urlToken: undefined, tail: '' };
+    }
+    // Endpoint invocation syntax can include spaces/commas/colons inside args, e.g.
+    // GET MultiParam(hello, world) or GET MultiParam(param1: foo, param2: bar)
+    const endpointCallMatch = trimmed.match(/^([a-zA-Z_][a-zA-Z0-9_-]*)\s*\(/);
+    if (endpointCallMatch) {
+        let depth = 0;
+        let inSingleQuote = false;
+        let inDoubleQuote = false;
+        let escaped = false;
+        for (let i = 0; i < trimmed.length; i++) {
+            const ch = trimmed[i];
+            if (escaped) {
+                escaped = false;
+                continue;
+            }
+            if (ch === '\\') {
+                escaped = true;
+                continue;
+            }
+            if (ch === '"' && !inSingleQuote) {
+                inDoubleQuote = !inDoubleQuote;
+                continue;
+            }
+            if (ch === '\'' && !inDoubleQuote) {
+                inSingleQuote = !inSingleQuote;
+                continue;
+            }
+            if (inSingleQuote || inDoubleQuote) {
+                continue;
+            }
+            if (ch === '(') {
+                depth++;
+                continue;
+            }
+            if (ch === ')') {
+                depth--;
+                if (depth === 0) {
+                    return {
+                        urlToken: trimmed.slice(0, i + 1).trim(),
+                        tail: trimmed.slice(i + 1).trim()
+                    };
+                }
+                continue;
+            }
+        }
+        // Unclosed endpoint-call args - likely still typing.
+        return { urlToken: undefined, tail: '' };
+    }
+    const firstSpace = trimmed.search(/\s/);
+    if (firstSpace === -1) {
+        return { urlToken: trimmed, tail: '' };
+    }
+    return {
+        urlToken: trimmed.slice(0, firstSpace),
+        tail: trimmed.slice(firstSpace).trim()
+    };
+}
+function stripRetryBackoffTokens(tail) {
+    return tail
+        .replace(/\bretry\s+\d+\b/gi, ' ')
+        .replace(/\bbackoff\s+\d+(?:\.\d+)?\s*(?:s|ms|seconds?|milliseconds?)?\b/gi, ' ')
+        .replace(/\s+/g, ' ')
+        .trim();
+}
+function isValidSequenceDeclarationLine(line) {
+    return /^(?:test\s+)?sequence\s+[a-zA-Z_][a-zA-Z0-9_-]*(?:\s*\([^)]*\))?\s*$/i.test(line.trim());
+}
+function isValidWaitCommandLine(line) {
+    return /^wait\s+\d+(?:\.\d+)?\s*(?:s|ms|seconds?|milliseconds?)?$/i.test(line.trim());
+}
+function isValidRunLikeCommandLine(line) {
+    const trimmed = line.trim();
+    // Script runs (including pwsh alias)
+    if (/^(?:var\s+[a-zA-Z_][a-zA-Z0-9_]*\s*=\s*)?run\s+(?:bash|powershell|pwsh|js)\s+.+$/i.test(trimmed)) {
+        return true;
+    }
+    // readJson command
+    if (/^(?:var\s+[a-zA-Z_][a-zA-Z0-9_]*\s*=\s*)?run\s+readjson\s+.+$/i.test(trimmed)) {
+        return true;
+    }
+    // SQL command
+    if (/^(?:var\s+[a-zA-Z_][a-zA-Z0-9_]*\s*=\s*)?run\s+sql\s+[a-zA-Z_][a-zA-Z0-9_-]*(?:\s*\([^)]*\))?\s*$/i.test(trimmed)) {
+        return true;
+    }
+    // MCP commands
+    if (/^(?:var\s+[a-zA-Z_][a-zA-Z0-9_]*\s*=\s*)?run\s+mcp\s+list\s+[a-zA-Z_][a-zA-Z0-9_-]*\s*$/i.test(trimmed)) {
+        return true;
+    }
+    if (/^(?:var\s+[a-zA-Z_][a-zA-Z0-9_]*\s*=\s*)?run\s+mcp\s+call\s+[a-zA-Z_][a-zA-Z0-9_-]*\s+[a-zA-Z_][a-zA-Z0-9_.:-]*(?:\s*\(.*\))?\s*$/i.test(trimmed)) {
+        return true;
+    }
+    // Named request / sequence runs with optional args + retry/backoff
+    if (/^run\s+[a-zA-Z_][a-zA-Z0-9_-]*(?:\s*\([^)]*\))?(?:\s+retry\s+\d+)?(?:\s+backoff\s+\d+(?:\.\d+)?\s*(?:s|ms|seconds?|milliseconds?)?)?$/i.test(trimmed)) {
+        return true;
+    }
+    if (/^var\s+[a-zA-Z_][a-zA-Z0-9_]*\s*=\s*run\s+[a-zA-Z_][a-zA-Z0-9_-]*(?:\s*\([^)]*\))?(?:\s+retry\s+\d+)?(?:\s+backoff\s+\d+(?:\.\d+)?\s*(?:s|ms|seconds?|milliseconds?)?)?$/i.test(trimmed)) {
+        return true;
+    }
+    return false;
+}
+function getHeaderValueCaseInsensitive(headers, headerName) {
+    const target = headerName.toLowerCase();
+    for (const [name, value] of Object.entries(headers)) {
+        if (name.toLowerCase() === target) {
+            return value;
+        }
+    }
+    return undefined;
+}
+function isJsonContentType(contentType) {
+    return typeof contentType === 'string' && contentType.toLowerCase().includes('json');
+}
+function isBareBodyVariableExpression(value) {
+    return /^[a-zA-Z_][a-zA-Z0-9_]*(?:\.[a-zA-Z_][a-zA-Z0-9_]*|\[\d+\])*$/.test(value.trim());
+}
+function normalizeJsonBodyForDiagnostics(value) {
+    // Norn placeholders may resolve to strings, numbers, objects, or arrays at runtime.
+    // Use null as a syntactically valid stand-in so diagnostics can still catch JSON structure errors.
+    return value.replace(/\{\{[^\r\n}]+\}\}/g, 'null');
+}
+function jsonLineCanEndWithoutComma(line) {
+    const trimmed = line.trim();
+    return !trimmed ||
+        trimmed.endsWith(',') ||
+        trimmed.endsWith('{') ||
+        trimmed.endsWith('[') ||
+        trimmed.endsWith(':');
+}
+function jsonLineCanStartWithoutComma(line) {
+    const trimmed = line.trim();
+    return !trimmed ||
+        trimmed.startsWith(',') ||
+        trimmed.startsWith('}') ||
+        trimmed.startsWith(']');
+}
+function createMissingJsonCommaDiagnostic(diagnostics, lines, previousLineNumber) {
+    const previousLine = lines[previousLineNumber] ?? '';
+    const endCol = previousLine.trimEnd().length;
+    const range = new vscode.Range(new vscode.Position(previousLineNumber, Math.max(0, endCol - 1)), new vscode.Position(previousLineNumber, Math.max(0, endCol)));
+    pushNornDiagnostic(diagnostics, range, `Invalid JSON body: missing comma after this property or value.`, vscode.DiagnosticSeverity.Error, 'invalid-json-body-missing-comma');
+}
+function findJsonBodyOffsetLocation(text, offset) {
+    const safeOffset = Math.max(0, Math.min(offset, text.length));
+    const before = text.slice(0, safeOffset);
+    const lineIndex = before.split('\n').length - 1;
+    const lastNewline = before.lastIndexOf('\n');
+    const column = lastNewline === -1 ? before.length : before.length - lastNewline - 1;
+    return { lineIndex, column };
+}
+function getJsonErrorLocation(error, text, bodyLines) {
+    if (!(error instanceof SyntaxError)) {
+        return undefined;
+    }
+    const message = error.message;
+    const lineColumnMatch = message.match(/line\s+(\d+)\s+column\s+(\d+)/i);
+    if (lineColumnMatch) {
+        const lineIndex = Math.max(0, Number(lineColumnMatch[1]) - 1);
+        const sourceLine = bodyLines[Math.min(lineIndex, bodyLines.length - 1)];
+        if (!sourceLine) {
+            return undefined;
+        }
+        return {
+            lineNumber: sourceLine.lineNumber,
+            column: Math.max(0, Number(lineColumnMatch[2]) - 1)
+        };
+    }
+    const positionMatch = message.match(/position\s+(\d+)/i);
+    if (positionMatch) {
+        const location = findJsonBodyOffsetLocation(text, Number(positionMatch[1]));
+        const sourceLine = bodyLines[Math.min(location.lineIndex, bodyLines.length - 1)];
+        if (!sourceLine) {
+            return undefined;
+        }
+        return {
+            lineNumber: sourceLine.lineNumber,
+            column: location.column
+        };
+    }
+    return undefined;
+}
+function validateJsonBodyLines(diagnostics, lines, bodyLines) {
+    if (bodyLines.length === 0) {
+        return;
+    }
+    const bodyText = bodyLines.map(line => line.text).join('\n').trim();
+    if (!bodyText || isBareBodyVariableExpression(bodyText)) {
+        return;
+    }
+    for (let i = 1; i < bodyLines.length; i++) {
+        const previous = bodyLines[i - 1];
+        const current = bodyLines[i];
+        if (!jsonLineCanEndWithoutComma(previous.text) && !jsonLineCanStartWithoutComma(current.text)) {
+            createMissingJsonCommaDiagnostic(diagnostics, lines, previous.lineNumber);
+            return;
+        }
+    }
+    const normalizedBodyText = normalizeJsonBodyForDiagnostics(bodyText);
+    try {
+        JSON.parse(normalizedBodyText);
+    }
+    catch (error) {
+        const location = getJsonErrorLocation(error, normalizedBodyText, bodyLines);
+        const lineNumber = location?.lineNumber ?? bodyLines[0].lineNumber;
+        const documentLine = lines[lineNumber] ?? '';
+        const startCol = Math.min(documentLine.length, location?.column ?? 0);
+        const range = new vscode.Range(new vscode.Position(lineNumber, startCol), new vscode.Position(lineNumber, Math.min(documentLine.length, startCol + 1)));
+        const message = error instanceof SyntaxError ? error.message : String(error);
+        pushNornDiagnostic(diagnostics, range, `Invalid JSON body: ${message}`, vscode.DiagnosticSeverity.Error, 'invalid-json-body');
+    }
+}
+const variablePathExpressionRegex = /^([a-zA-Z_][a-zA-Z0-9_]*)(?:\.[a-zA-Z_][a-zA-Z0-9_]*|\[\d+\])*$/;
+const literalExpressionWords = new Set([
+    'true',
+    'false',
+    'null',
+    'string',
+    'number',
+    'boolean',
+    'object',
+    'array',
+    'undefined'
+]);
+function isQuotedExpression(expr) {
+    return (expr.startsWith('"') && expr.endsWith('"')) ||
+        (expr.startsWith("'") && expr.endsWith("'"));
+}
+function getBaseVariableRead(expression) {
+    const trimmed = expression.trim();
+    if (!trimmed ||
+        trimmed.startsWith('$') ||
+        trimmed.startsWith('{{') ||
+        isQuotedExpression(trimmed) ||
+        /^-?\d+(?:\.\d+)?$/.test(trimmed) ||
+        trimmed === '[]' ||
+        trimmed === '{}') {
+        return undefined;
+    }
+    const match = trimmed.match(variablePathExpressionRegex);
+    if (!match) {
+        return undefined;
+    }
+    const name = match[1];
+    if (literalExpressionWords.has(name.toLowerCase())) {
+        return undefined;
+    }
+    const leadingWhitespace = expression.length - expression.trimStart().length;
+    return {
+        name,
+        start: leadingWhitespace,
+        end: leadingWhitespace + name.length
+    };
+}
+function getBareTemplateExpressionRead(expression) {
+    const trimmed = expression.trim();
+    const match = trimmed.match(/^\{\{\s*((\$\d+|[a-zA-Z_][a-zA-Z0-9_]*)(?:\.[a-zA-Z_][a-zA-Z0-9_-]*|\[\d+\])*)\s*\}\}$/);
+    if (!match) {
+        return undefined;
+    }
+    const leadingWhitespace = expression.length - expression.trimStart().length;
+    return {
+        name: match[2],
+        replacement: match[1],
+        start: leadingWhitespace,
+        end: leadingWhitespace + trimmed.length
+    };
+}
+function splitCommaSeparatedExpressions(content) {
+    const parts = [];
+    let current = '';
+    let currentStart = 0;
+    let quoteChar = null;
+    let templateDepth = 0;
+    let bracketDepth = 0;
+    const pushCurrent = () => {
+        const leadingWhitespace = current.length - current.trimStart().length;
+        const text = current.trim();
+        if (text) {
+            parts.push({
+                text,
+                start: currentStart + leadingWhitespace
+            });
+        }
+        current = '';
+    };
+    for (let i = 0; i < content.length; i++) {
+        const char = content[i];
+        const next = i + 1 < content.length ? content[i + 1] : '';
+        const prev = i > 0 ? content[i - 1] : '';
+        if (quoteChar) {
+            current += char;
+            if (char === quoteChar && prev !== '\\') {
+                quoteChar = null;
+            }
+            continue;
+        }
+        if (char === '"' || char === "'") {
+            quoteChar = char;
+            current += char;
+            continue;
+        }
+        if (char === '{' && next === '{') {
+            templateDepth++;
+            current += '{{';
+            i++;
+            continue;
+        }
+        if (char === '}' && next === '}' && templateDepth > 0) {
+            templateDepth--;
+            current += '}}';
+            i++;
+            continue;
+        }
+        if (templateDepth === 0) {
+            if (char === '(' || char === '[' || char === '{') {
+                bracketDepth++;
+                current += char;
+                continue;
+            }
+            if (char === ')' || char === ']' || char === '}') {
+                bracketDepth = Math.max(0, bracketDepth - 1);
+                current += char;
+                continue;
+            }
+            if (char === ',' && bracketDepth === 0) {
+                pushCurrent();
+                currentStart = i + 1;
+                continue;
+            }
+        }
+        current += char;
+    }
+    pushCurrent();
+    return parts;
+}
+function getContainingSequence(sequences, lineNumber) {
+    return sequences.find(seq => lineNumber > seq.startLine && lineNumber < seq.endLine);
+}
+function getAvailableVariablesForLine(sequences, globalVariables, lineNumber) {
+    const containingSeq = getContainingSequence(sequences, lineNumber);
+    if (!containingSeq) {
+        return new Set(Object.keys(globalVariables));
+    }
+    const localVars = getSequenceLocalVariables(containingSeq.content, containingSeq.parameters);
+    return new Set([...Object.keys(globalVariables), ...localVars]);
+}
+function getAvailableNonEnvironmentVariablesForLine(sequences, fileLevelVariables, lineNumber) {
+    const containingSeq = getContainingSequence(sequences, lineNumber);
+    if (!containingSeq) {
+        return new Set(Object.keys(fileLevelVariables));
+    }
+    const localVars = getSequenceLocalVariables(containingSeq.content, containingSeq.parameters);
+    return new Set([...Object.keys(fileLevelVariables), ...localVars]);
+}
+function addUndefinedBaseVariableDiagnostic(diagnostics, lineNumber, startCol, varName) {
+    const safeStartCol = Math.max(0, startCol);
+    const range = new vscode.Range(new vscode.Position(lineNumber, safeStartCol), new vscode.Position(lineNumber, safeStartCol + varName.length));
+    if (diagnostics.some(d => d.range.start.line === range.start.line &&
+        d.range.start.character === range.start.character &&
+        d.range.end.character === range.end.character &&
+        d.code === 'undefined-variable')) {
+        return;
+    }
+    pushNornDiagnostic(diagnostics, range, `Undefined variable: '${varName}'`, vscode.DiagnosticSeverity.Error, 'undefined-variable');
+}
+function addUndefinedVariableReadDiagnostic(diagnostics, expression, expressionStartCol, lineNumber, availableVars) {
+    const read = getBaseVariableRead(expression);
+    if (!read || availableVars.has(read.name)) {
+        return;
+    }
+    addUndefinedBaseVariableDiagnostic(diagnostics, lineNumber, expressionStartCol + read.start, read.name);
+}
+function addBareTemplateExpressionDiagnostic(diagnostics, expression, expressionStartCol, lineNumber, environmentVariableNames, nonEnvironmentVariableNames) {
+    const read = getBareTemplateExpressionRead(expression);
+    if (!read) {
+        return;
+    }
+    if (environmentVariableNames.has(read.name) && !nonEnvironmentVariableNames.has(read.name)) {
+        return;
+    }
+    const startCol = Math.max(0, expressionStartCol + read.start);
+    const range = new vscode.Range(new vscode.Position(lineNumber, startCol), new vscode.Position(lineNumber, startCol + read.end - read.start));
+    if (diagnostics.some(d => d.range.start.line === range.start.line &&
+        d.range.start.character === range.start.character &&
+        d.range.end.character === range.end.character &&
+        d.code === 'bare-template-expression')) {
+        return;
+    }
+    pushNornDiagnostic(diagnostics, range, `Use '${read.replacement}' directly in assertions and conditions; reserve {{...}} for quoted strings and request templates.`, vscode.DiagnosticSeverity.Error, 'bare-template-expression');
+}
+/**
+ * Tokenize print statement content into individual tokens.
+ * Respects quoted strings and splits on operators/whitespace.
+ */
+function tokenizePrintContent(content) {
+    const tokens = [];
+    let current = '';
+    let currentStart = 0;
+    let inString = false;
+    let stringChar = '';
+    let i = 0;
+    const pushToken = () => {
+        if (current.trim()) {
+            tokens.push({ text: current.trim(), start: currentStart + (current.length - current.trimStart().length) });
+        }
+        current = '';
+    };
+    while (i < content.length) {
+        const char = content[i];
+        if (inString) {
+            current += char;
+            if (char === stringChar && content[i - 1] !== '\\') {
+                inString = false;
+                pushToken();
+            }
+            i++;
+            continue;
+        }
+        // Start of string
+        if (char === '"' || char === "'") {
+            pushToken();
+            inString = true;
+            stringChar = char;
+            current = char;
+            currentStart = i;
+            i++;
+            continue;
+        }
+        // Operators and whitespace are delimiters
+        if (/[\s+\-*/|&<>=!]/.test(char)) {
+            pushToken();
+            // If it's an operator, add it as its own token
+            if (/[+\-*/|&<>=!]/.test(char)) {
+                tokens.push({ text: char, start: i });
+            }
+            currentStart = i + 1;
+            i++;
+            continue;
+        }
+        // Regular character
+        if (current === '') {
+            currentStart = i;
+        }
+        current += char;
+        i++;
+    }
+    // Push any remaining token
+    pushToken();
+    return tokens;
+}
+class DiagnosticProvider {
+    diagnosticCollection;
+    workspaceRefreshPromise;
+    workspaceRefreshQueued = false;
+    constructor() {
+        this.diagnosticCollection = vscode.languages.createDiagnosticCollection('norn');
+    }
+    isSupportedLanguage(document) {
+        return document.languageId === 'norn' ||
+            document.languageId === 'nornsql' ||
+            document.languageId === 'nornapi' ||
+            document.languageId === 'nornenv';
+    }
+    async refreshWorkspaceDiagnostics() {
+        if (this.workspaceRefreshPromise) {
+            this.workspaceRefreshQueued = true;
+            return this.workspaceRefreshPromise;
+        }
+        this.workspaceRefreshPromise = (async () => {
+            do {
+                this.workspaceRefreshQueued = false;
+                await this.refreshWorkspaceDiagnosticsInternal();
+            } while (this.workspaceRefreshQueued);
+        })().finally(() => {
+            this.workspaceRefreshPromise = undefined;
+        });
+        return this.workspaceRefreshPromise;
+    }
+    async refreshWorkspaceDiagnosticsInternal() {
+        const openDocsByUri = new Map();
+        for (const doc of vscode.workspace.textDocuments) {
+            if (this.isSupportedLanguage(doc)) {
+                openDocsByUri.set(doc.uri.toString(), doc);
+                this.updateDiagnostics(doc);
+            }
+        }
+        let uris = [];
+        try {
+            uris = await vscode.workspace.findFiles('**/*.{norn,nornsql,nornapi,nornenv}', '**/{node_modules,.git}/**');
+        }
+        catch {
+            return;
+        }
+        for (const uri of uris) {
+            if (openDocsByUri.has(uri.toString())) {
+                continue;
+            }
+            try {
+                const doc = await vscode.workspace.openTextDocument(uri);
+                if (this.isSupportedLanguage(doc)) {
+                    this.updateDiagnostics(doc);
+                }
+            }
+            catch {
+                // Ignore files that cannot be opened/read during background refresh
+            }
+        }
+    }
+    createWholeLineRange(document, lineNumber) {
+        const safeLine = Math.max(0, Math.min(lineNumber, Math.max(document.lineCount - 1, 0)));
+        const text = document.lineCount > 0 ? document.lineAt(safeLine).text : '';
+        return new vscode.Range(new vscode.Position(safeLine, 0), new vscode.Position(safeLine, text.length));
+    }
+    updateNornsqlDiagnostics(document) {
+        const diagnostics = [];
+        const parsed = (0, nornSqlParser_1.parseNornSqlFile)(document.getText(), document.uri.fsPath);
+        const lines = document.getText().split('\n');
+        for (const error of parsed.errors) {
+            const range = this.createWholeLineRange(document, error.lineNumber);
+            pushNornDiagnostic(diagnostics, range, error.message, vscode.DiagnosticSeverity.Error, 'nornsql-parse');
+        }
+        const connectionLine = lines.findIndex(line => /^\s*connection\b/i.test(line));
+        if (parsed.connectionName) {
+            const range = this.createWholeLineRange(document, connectionLine >= 0 ? connectionLine : 0);
+            try {
+                const projectConfig = (0, sqlConfig_1.loadNornSqlProjectConfig)(document.uri.fsPath).config;
+                const connection = projectConfig.connections[parsed.connectionName];
+                if (!connection) {
+                    pushNornDiagnostic(diagnostics, range, `Connection alias '${parsed.connectionName}' was not found in ${nornConfig_1.NORN_CONFIG_FILENAME} sql.connections.`, vscode.DiagnosticSeverity.Error, 'nornsql-unknown-connection');
+                }
+                else {
+                    const adapterValidation = (0, sqlConfig_1.validateSqlAdapterReference)(document.uri.fsPath, connection.adapter);
+                    if (!adapterValidation.ok && adapterValidation.message) {
+                        pushNornDiagnostic(diagnostics, range, adapterValidation.message, vscode.DiagnosticSeverity.Error, 'nornsql-unknown-adapter');
+                    }
+                }
+            }
+            catch (error) {
+                pushNornDiagnostic(diagnostics, range, error instanceof Error ? error.message : String(error), vscode.DiagnosticSeverity.Error, 'nornsql-invalid-config');
+            }
+        }
+        this.diagnosticCollection.set(document.uri, diagnostics);
+    }
+    updateDiagnostics(document) {
+        if (document.languageId === 'nornenv') {
+            this.updateNornenvDiagnostics(document);
+            return;
+        }
+        if (document.languageId === 'nornapi') {
+            this.updateNornapiDiagnostics(document);
+            return;
+        }
+        if (document.languageId === 'nornsql') {
+            this.updateNornsqlDiagnostics(document);
+            return;
+        }
+        if (document.languageId !== 'norn') {
+            return;
+        }
+        const diagnostics = [];
+        const text = document.getText();
+        // Extract file-level variables (outside sequences) + environment
+        const fileLevelVariables = (0, parser_1.extractFileLevelVariables)(text);
+        const envVariables = (0, environmentProvider_1.getEnvironmentVariables)(document.uri.fsPath);
+        const declaredEnvironmentVariableNames = getAllDeclaredEnvironmentVariableNames(document.uri.fsPath);
+        const environmentVariableNames = new Set([
+            ...Object.keys(envVariables),
+            ...declaredEnvironmentVariableNames
+        ]);
+        const globalVariables = { ...envVariables, ...fileLevelVariables };
+        // Extract sequences for scope-aware checking
+        const sequences = (0, sequenceRunner_1.extractSequences)(text);
+        const lines = text.split('\n');
+        // Check for duplicate sequence declarations
+        const declaredSequences = new Map(); // seqName -> first declaration line
+        for (const seq of sequences) {
+            if (declaredSequences.has(seq.name)) {
+                const firstLine = declaredSequences.get(seq.name);
+                const range = createTokenRange(lines, seq.startLine, seq.name);
+                pushNornDiagnostic(diagnostics, range, `Duplicate sequence: '${seq.name}' is already declared on line ${firstLine + 1}.`, vscode.DiagnosticSeverity.Error, 'duplicate-sequence');
+            }
+            else {
+                declaredSequences.set(seq.name, seq.startLine);
+            }
+        }
+        // Warn when sequence parameters shadow environment variables.
+        for (const seq of sequences) {
+            if (!seq.parameters || seq.parameters.length === 0) {
+                continue;
+            }
+            let declarationLine = seq.startLine;
+            for (let i = seq.startLine; i <= seq.endLine; i++) {
+                if (/^\s*(?:test\s+)?sequence\s+/.test(lines[i])) {
+                    declarationLine = i;
+                    break;
+                }
+            }
+            const declarationText = lines[declarationLine];
+            for (const param of seq.parameters) {
+                if (!(param.name in envVariables)) {
+                    continue;
+                }
+                const startCol = declarationText.indexOf(param.name);
+                if (startCol < 0) {
+                    continue;
+                }
+                const range = new vscode.Range(new vscode.Position(declarationLine, startCol), new vscode.Position(declarationLine, startCol + param.name.length));
+                pushNornDiagnostic(diagnostics, range, `Sequence parameter '${param.name}' shadows environment variable '${param.name}'. Use {{$env.${param.name}}} to access the env value explicitly.`, vscode.DiagnosticSeverity.Warning, 'env-variable-shadowed');
+            }
+        }
+        // Check for duplicate variable declarations at file level (outside sequences)
+        const varDeclRegex = /^\s*var\s+([a-zA-Z_][a-zA-Z0-9_]*)\s*=/;
+        const declaredVars = new Map(); // varName -> first declaration line
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i];
+            // Skip comment lines
+            if (isCommentLine(line)) {
+                continue;
+            }
+            // Check if this line is inside a sequence (skip sequence-local vars)
+            const isInsideSequence = sequences.some(seq => i > seq.startLine && i < seq.endLine);
+            if (isInsideSequence) {
+                continue;
+            }
+            const lineWithoutComment = (0, stringUtils_1.stripInlineComment)(line);
+            const varMatch = lineWithoutComment.match(varDeclRegex);
+            if (varMatch) {
+                const varName = varMatch[1];
+                if (declaredVars.has(varName)) {
+                    const firstLine = declaredVars.get(varName);
+                    const startCol = line.indexOf(varName);
+                    const range = new vscode.Range(new vscode.Position(i, startCol), new vscode.Position(i, startCol + varName.length));
+                    pushNornDiagnostic(diagnostics, range, `Duplicate variable declaration: '${varName}' is already declared on line ${firstLine + 1}.`, vscode.DiagnosticSeverity.Error, 'duplicate-variable');
+                }
+                else {
+                    declaredVars.set(varName, i);
+                }
+                if (varName in envVariables) {
+                    const startCol = line.indexOf(varName);
+                    const range = new vscode.Range(new vscode.Position(i, startCol), new vscode.Position(i, startCol + varName.length));
+                    pushNornDiagnostic(diagnostics, range, `File variable '${varName}' shadows environment variable '${varName}'. Use {{$env.${varName}}} to access the env value explicitly.`, vscode.DiagnosticSeverity.Warning, 'env-variable-shadowed');
+                }
+            }
+        }
+        // Check for invalid named request declarations (names with spaces) and duplicates
+        const invalidNameRegex = /^\s*\[(?:Name:\s*)?(.+)\]\s*$/;
+        const namedRequestRegex = /^\s*\[(?:Name:\s*)?([a-zA-Z_][a-zA-Z0-9_-]*)\]/;
+        const validNameRegex = /^[a-zA-Z_][a-zA-Z0-9_-]*$/;
+        const declaredNamedRequests = new Map(); // name -> first declaration line
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i];
+            // Skip comment lines
+            if (isCommentLine(line)) {
+                continue;
+            }
+            // Strip inline comments before checking
+            const lineWithoutComment = (0, stringUtils_1.stripInlineComment)(line);
+            // Check for valid named request and track for duplicates
+            const namedMatch = lineWithoutComment.match(namedRequestRegex);
+            if (namedMatch) {
+                const name = namedMatch[1];
+                if (declaredNamedRequests.has(name)) {
+                    const firstLine = declaredNamedRequests.get(name);
+                    const startCol = line.indexOf('[');
+                    const endCol = line.indexOf(']') + 1;
+                    const range = new vscode.Range(new vscode.Position(i, startCol), new vscode.Position(i, endCol));
+                    pushNornDiagnostic(diagnostics, range, `Duplicate named request: '${name}' is already declared on line ${firstLine + 1}.`, vscode.DiagnosticSeverity.Error, 'duplicate-named-request');
+                }
+                else {
+                    declaredNamedRequests.set(name, i);
+                }
+            }
+            // Check for invalid names (with spaces etc)
+            const match = lineWithoutComment.match(invalidNameRegex);
+            if (match) {
+                const name = match[1].trim();
+                if (!validNameRegex.test(name)) {
+                    const startCol = line.indexOf('[');
+                    const endCol = line.indexOf(']') + 1;
+                    const range = new vscode.Range(new vscode.Position(i, startCol), new vscode.Position(i, endCol));
+                    pushNornDiagnostic(diagnostics, range, `Invalid request name: '${name}'. Names cannot contain spaces and must start with a letter or underscore.`, vscode.DiagnosticSeverity.Error, 'invalid-request-name');
+                }
+            }
+        }
+        // Check for import statement errors
+        const imports = (0, parser_1.extractImports)(text);
+        const documentDir = path.dirname(document.uri.fsPath);
+        // Track imported names with source info for duplicate detection
+        // Maps name (lowercase) -> { sourcePath, lineNumber }
+        const importedRequests = new Map();
+        const importedSequences = new Map();
+        // Track imported API definitions (endpoints and header groups from .nornapi files)
+        // Maps name -> { sourcePath, lineNumber } to detect duplicates
+        const importedEndpoints = new Map();
+        const importedHeaderGroups = new Map();
+        const importedSqlOperations = new Map();
+        let sqlProjectConfig;
+        let sqlProjectConfigError;
+        let sqlProjectConfigLoadAttempted = false;
+        const loadSqlProjectConfig = () => {
+            if (sqlProjectConfigLoadAttempted) {
+                return sqlProjectConfig;
+            }
+            sqlProjectConfigLoadAttempted = true;
+            try {
+                sqlProjectConfig = (0, sqlConfig_1.loadNornSqlProjectConfig)(document.uri.fsPath).config;
+            }
+            catch (error) {
+                sqlProjectConfigError = error instanceof Error ? error.message : String(error);
+            }
+            return sqlProjectConfig;
+        };
+        for (const imp of imports) {
+            const absolutePath = path.resolve(documentDir, imp.path);
+            // Check if file exists
+            if (!fs.existsSync(absolutePath)) {
+                const range = createTokenRange(lines, imp.lineNumber, imp.path);
+                pushNornDiagnostic(diagnostics, range, `Import file not found: '${imp.path}'`, vscode.DiagnosticSeverity.Error, 'import-not-found');
+            }
+            else {
+                // Read the imported file and extract its named requests/sequences
+                try {
+                    const importedContent = fs.readFileSync(absolutePath, 'utf-8');
+                    // Check if this is a .nornapi file
+                    if (imp.path.endsWith('.nornsql')) {
+                        const parsedSql = (0, nornSqlParser_1.parseNornSqlFile)(importedContent, absolutePath);
+                        for (const parseError of parsedSql.errors) {
+                            const range = createTokenRange(lines, imp.lineNumber, imp.path);
+                            pushNornDiagnostic(diagnostics, range, parseError.message, vscode.DiagnosticSeverity.Error, 'invalid-nornsql-import');
+                        }
+                        const loadedSqlConfig = loadSqlProjectConfig();
+                        if (sqlProjectConfigError) {
+                            const range = createTokenRange(lines, imp.lineNumber, imp.path);
+                            pushNornDiagnostic(diagnostics, range, sqlProjectConfigError, vscode.DiagnosticSeverity.Error, 'invalid-nornsql-config');
+                        }
+                        else if (parsedSql.connectionName && loadedSqlConfig && !loadedSqlConfig.connections[parsedSql.connectionName]) {
+                            const range = createTokenRange(lines, imp.lineNumber, imp.path);
+                            pushNornDiagnostic(diagnostics, range, `Connection alias '${parsedSql.connectionName}' was not found in ${nornConfig_1.NORN_CONFIG_FILENAME} sql.connections.`, vscode.DiagnosticSeverity.Error, 'unknown-nornsql-connection');
+                        }
+                        else if (parsedSql.connectionName && loadedSqlConfig) {
+                            const adapterValidation = (0, sqlConfig_1.validateSqlAdapterReference)(document.uri.fsPath, loadedSqlConfig.connections[parsedSql.connectionName].adapter);
+                            if (!adapterValidation.ok && adapterValidation.message) {
+                                const range = createTokenRange(lines, imp.lineNumber, imp.path);
+                                pushNornDiagnostic(diagnostics, range, adapterValidation.message, vscode.DiagnosticSeverity.Error, 'unknown-nornsql-adapter');
+                            }
+                        }
+                        for (const operation of parsedSql.operations) {
+                            const lowerName = operation.name.toLowerCase();
+                            const existing = importedSqlOperations.get(lowerName);
+                            if (existing) {
+                                const range = createTokenRange(lines, imp.lineNumber, imp.path);
+                                pushNornDiagnostic(diagnostics, range, `Duplicate SQL operation '${operation.name}': already defined in '${existing.sourcePath}'`, vscode.DiagnosticSeverity.Error, 'duplicate-sql-operation-import');
+                            }
+                            else {
+                                importedSqlOperations.set(lowerName, { sourcePath: imp.path, operation });
+                            }
+                        }
+                    }
+                    else if (imp.path.endsWith('.nornapi')) {
+                        const apiDef = (0, nornapiParser_1.parseNornApiFile)(importedContent);
+                        for (const endpoint of apiDef.endpoints) {
+                            const existing = importedEndpoints.get(endpoint.name);
+                            if (existing) {
+                                const range = createTokenRange(lines, imp.lineNumber, imp.path);
+                                pushNornDiagnostic(diagnostics, range, `Duplicate endpoint '${endpoint.name}': already defined in '${existing.sourcePath}'`, vscode.DiagnosticSeverity.Error, 'duplicate-endpoint');
+                            }
+                            else {
+                                importedEndpoints.set(endpoint.name, { sourcePath: imp.path, lineNumber: imp.lineNumber });
+                            }
+                        }
+                        for (const group of apiDef.headerGroups) {
+                            const existing = importedHeaderGroups.get(group.name);
+                            if (existing) {
+                                const range = createTokenRange(lines, imp.lineNumber, imp.path);
+                                pushNornDiagnostic(diagnostics, range, `Duplicate header group '${group.name}': already defined in '${existing.sourcePath}'`, vscode.DiagnosticSeverity.Error, 'duplicate-header-group');
+                            }
+                            else {
+                                importedHeaderGroups.set(group.name, {
+                                    sourcePath: imp.path,
+                                    lineNumber: imp.lineNumber,
+                                    headerGroup: group
+                                });
+                            }
+                        }
+                    }
+                    else {
+                        // Regular .norn file
+                        const fileRequests = (0, parser_1.extractNamedRequests)(importedContent);
+                        const fileSequences = (0, sequenceRunner_1.extractSequences)(importedContent);
+                        // Check for duplicate named requests
+                        for (const req of fileRequests) {
+                            const lowerName = req.name.toLowerCase();
+                            const existing = importedRequests.get(lowerName);
+                            if (existing) {
+                                const range = createTokenRange(lines, imp.lineNumber, imp.path);
+                                pushNornDiagnostic(diagnostics, range, `Duplicate named request '${req.name}': already defined in '${existing.sourcePath}'`, vscode.DiagnosticSeverity.Error, 'duplicate-named-request-import');
+                            }
+                            else {
+                                importedRequests.set(lowerName, { sourcePath: imp.path, lineNumber: imp.lineNumber });
+                            }
+                        }
+                        // Check for duplicate sequences
+                        for (const seq of fileSequences) {
+                            const lowerName = seq.name.toLowerCase();
+                            const existing = importedSequences.get(lowerName);
+                            if (existing) {
+                                const range = createTokenRange(lines, imp.lineNumber, imp.path);
+                                pushNornDiagnostic(diagnostics, range, `Duplicate sequence '${seq.name}': already defined in '${existing.sourcePath}'`, vscode.DiagnosticSeverity.Error, 'duplicate-sequence-import');
+                            }
+                            else {
+                                importedSequences.set(lowerName, { sourcePath: imp.path, lineNumber: imp.lineNumber });
+                            }
+                        }
+                    }
+                }
+                catch {
+                    // Ignore read errors - file exists but couldn't be read
+                }
+            }
+        }
+        // Check for misplaced tags/annotations.
+        // Any @decorator line must be directly associated with a following sequence declaration.
+        const tagPattern = /^\s*@([a-zA-Z_][a-zA-Z0-9_-]*)(?:\(([^)]*)\))?/;
+        const sequencePattern = /^\s*(?:test\s+)?sequence\s+[a-zA-Z_][a-zA-Z0-9_-]*/;
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i];
+            // Skip comment lines
+            if (isCommentLine(line)) {
+                continue;
+            }
+            // Check if this line contains a tag/annotation decorator
+            if (tagPattern.test(line)) {
+                // Look ahead to find what this decorator applies to
+                let foundSequence = false;
+                let j = i + 1;
+                // Skip empty lines and additional decorator lines
+                while (j < lines.length) {
+                    const nextLine = lines[j].trim();
+                    if (!nextLine) {
+                        j++;
+                        continue;
+                    }
+                    if (tagPattern.test(nextLine)) {
+                        j++;
+                        continue;
+                    }
+                    if (sequencePattern.test(nextLine)) {
+                        foundSequence = true;
+                    }
+                    break;
+                }
+                const tagMatch = line.match(/@([a-zA-Z_][a-zA-Z0-9_-]*)(?:\([^)]+\))?/);
+                if (tagMatch) {
+                    const startCol = line.indexOf('@');
+                    const range = new vscode.Range(new vscode.Position(i, startCol), new vscode.Position(i, startCol + tagMatch[0].length));
+                    if (!foundSequence) {
+                        const annotationName = tagMatch[1];
+                        const isDataAnnotation = annotationName === 'data' || annotationName === 'theory';
+                        const message = isDataAnnotation
+                            ? `@${annotationName} must be placed immediately before a sequence declaration.`
+                            : `Tags must be placed immediately before a sequence declaration.`;
+                        pushNornDiagnostic(diagnostics, range, message, vscode.DiagnosticSeverity.Error, 'misplaced-tag');
+                    }
+                }
+            }
+        }
+        // Check for test sequences with required parameters but no @data/@theory
+        for (const seq of sequences) {
+            if (seq.isTest) {
+                const requiredParams = seq.parameters.filter(p => p.defaultValue === undefined);
+                if (requiredParams.length > 0 && !seq.theoryData) {
+                    // Find the line with the 'test sequence' declaration
+                    let declarationLine = seq.startLine;
+                    for (let i = seq.startLine; i <= seq.endLine; i++) {
+                        if (/^\s*test\s+sequence\s+/.test(lines[i])) {
+                            declarationLine = i;
+                            break;
+                        }
+                    }
+                    const line = lines[declarationLine];
+                    const startCol = line.indexOf('test');
+                    const endCol = line.length;
+                    const range = new vscode.Range(new vscode.Position(declarationLine, startCol), new vscode.Position(declarationLine, endCol));
+                    const paramNames = requiredParams.map(p => p.name).join(', ');
+                    pushNornDiagnostic(diagnostics, range, `Test sequence '${seq.name}' has required parameters (${paramNames}) but no @data or @theory annotation. Add @data(...) or @theory("file.json") to provide test values.`, vscode.DiagnosticSeverity.Error, 'test-missing-data');
+                }
+            }
+        }
+        // Check for undefined named requests/sequences in 'run' commands
+        const namedRequests = (0, parser_1.extractNamedRequests)(text);
+        const namedRequestNames = new Set(namedRequests.map(r => r.name.toLowerCase()));
+        const sequenceNames = new Set(sequences.map(s => s.name.toLowerCase()));
+        // Build a map of sequence name -> required parameter count
+        const sequenceParamInfo = new Map();
+        for (const seq of sequences) {
+            const requiredParams = seq.parameters.filter(p => p.defaultValue === undefined).length;
+            sequenceParamInfo.set(seq.name.toLowerCase(), { required: requiredParams, total: seq.parameters.length });
+        }
+        // Updated regex to capture optional arguments: run Name or run Name(args)
+        const runCommandRegex = /^\s*(?:var\s+[a-zA-Z_][a-zA-Z0-9_]*\s*=\s*)?run\s+([a-zA-Z_][a-zA-Z0-9_-]*)(?:\(([^)]*)\))?\s*$/;
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i];
+            // Skip comment lines
+            if (isCommentLine(line)) {
+                continue;
+            }
+            const match = line.match(runCommandRegex);
+            if (match) {
+                const requestName = match[1];
+                const argsStr = match[2]; // undefined if no parens, empty string if (), or "arg1, arg2"
+                const lowerName = requestName.toLowerCase();
+                // Skip if it's a script command
+                if (['bash', 'js', 'powershell', 'readjson', 'sql'].includes(lowerName)) {
+                    continue;
+                }
+                // Check if it's a local named request, local sequence, or imported
+                const isLocalRequest = namedRequestNames.has(lowerName);
+                const isLocalSequence = sequenceNames.has(lowerName);
+                const isImportedRequest = importedRequests.has(lowerName);
+                const isImportedSequence = importedSequences.has(lowerName);
+                if (!isLocalRequest && !isLocalSequence && !isImportedRequest && !isImportedSequence) {
+                    const startCol = line.indexOf(requestName);
+                    const range = new vscode.Range(new vscode.Position(i, startCol), new vscode.Position(i, startCol + requestName.length));
+                    pushNornDiagnostic(diagnostics, range, `Undefined request or sequence: '${requestName}'`, vscode.DiagnosticSeverity.Error, 'undefined-request');
+                }
+                else if (isLocalSequence) {
+                    // Check if sequence requires parameters but none were provided
+                    const paramInfo = sequenceParamInfo.get(lowerName);
+                    if (paramInfo && paramInfo.required > 0) {
+                        // Count provided arguments
+                        let providedCount = 0;
+                        if (argsStr !== undefined && argsStr.trim() !== '') {
+                            // Split by comma, but respect quoted strings
+                            const args = argsStr.split(',').map(a => a.trim()).filter(a => a !== '');
+                            providedCount = args.length;
+                        }
+                        if (providedCount < paramInfo.required) {
+                            const startCol = line.indexOf(requestName);
+                            const range = new vscode.Range(new vscode.Position(i, startCol), new vscode.Position(i, startCol + requestName.length));
+                            const seq = sequences.find(s => s.name.toLowerCase() === lowerName);
+                            const requiredParamNames = seq ?
+                                seq.parameters.filter(p => p.defaultValue === undefined).map(p => p.name).join(', ') :
+                                '';
+                            pushNornDiagnostic(diagnostics, range, `Sequence '${requestName}' requires ${paramInfo.required} parameter(s): ${requiredParamNames}`, vscode.DiagnosticSeverity.Error, 'missing-sequence-parameters');
+                        }
+                    }
+                }
+            }
+        }
+        const runSqlRegex = /^\s*(?:var\s+[a-zA-Z_][a-zA-Z0-9_]*\s*=\s*)?run\s+sql\b/i;
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i];
+            if (isCommentLine(line) || !runSqlRegex.test(line)) {
+                continue;
+            }
+            const parsed = (0, sequenceRunner_1.parseRunSqlCommand)(line);
+            if (!parsed) {
+                continue;
+            }
+            const sqlKeywordStart = line.toLowerCase().indexOf('sql');
+            const baseRange = new vscode.Range(new vscode.Position(i, Math.max(0, sqlKeywordStart)), new vscode.Position(i, Math.max(0, sqlKeywordStart) + 3));
+            if (parsed.error) {
+                pushNornDiagnostic(diagnostics, baseRange, parsed.error, vscode.DiagnosticSeverity.Error, 'invalid-run-sql');
+                continue;
+            }
+            const operationInfo = importedSqlOperations.get(parsed.operationName.toLowerCase());
+            if (!operationInfo) {
+                const startCol = line.indexOf(parsed.operationName);
+                const range = new vscode.Range(new vscode.Position(i, Math.max(0, startCol)), new vscode.Position(i, Math.max(0, startCol) + parsed.operationName.length));
+                pushNornDiagnostic(diagnostics, range, `SQL operation '${parsed.operationName}' was not found in the SQL files imported by this .norn file.`, vscode.DiagnosticSeverity.Error, 'undefined-sql-operation');
+                continue;
+            }
+            const seenArgs = new Set();
+            const declaredArgs = operationInfo.operation.parameters;
+            let positionalIndex = 0;
+            for (const arg of parsed.args) {
+                if (arg.name) {
+                    const lowerName = arg.name.toLowerCase();
+                    const startCol = line.indexOf(arg.name);
+                    const range = new vscode.Range(new vscode.Position(i, Math.max(0, startCol)), new vscode.Position(i, Math.max(0, startCol) + arg.name.length));
+                    if (seenArgs.has(lowerName)) {
+                        pushNornDiagnostic(diagnostics, range, `Duplicate SQL parameter '${arg.name}' in run sql call.`, vscode.DiagnosticSeverity.Error, 'duplicate-sql-arg');
+                        continue;
+                    }
+                    const declaredParam = declaredArgs.find(param => param.toLowerCase() === lowerName);
+                    if (!declaredParam) {
+                        pushNornDiagnostic(diagnostics, range, `Unknown SQL parameter '${arg.name}'.`, vscode.DiagnosticSeverity.Error, 'unknown-sql-arg');
+                        continue;
+                    }
+                    seenArgs.add(declaredParam.toLowerCase());
+                    continue;
+                }
+                if (positionalIndex >= declaredArgs.length) {
+                    const startCol = line.indexOf(parsed.operationName);
+                    const range = new vscode.Range(new vscode.Position(i, Math.max(0, startCol)), new vscode.Position(i, Math.max(0, startCol) + parsed.operationName.length));
+                    pushNornDiagnostic(diagnostics, range, `Too many SQL arguments: expected ${declaredArgs.length}.`, vscode.DiagnosticSeverity.Error, 'too-many-sql-args');
+                    break;
+                }
+                seenArgs.add(declaredArgs[positionalIndex].toLowerCase());
+                positionalIndex++;
+            }
+            for (const param of operationInfo.operation.parameters) {
+                if (seenArgs.has(param.toLowerCase())) {
+                    continue;
+                }
+                const startCol = line.indexOf(parsed.operationName);
+                const range = new vscode.Range(new vscode.Position(i, Math.max(0, startCol)), new vscode.Position(i, Math.max(0, startCol) + parsed.operationName.length));
+                pushNornDiagnostic(diagnostics, range, `Missing required SQL parameter '${param}'.`, vscode.DiagnosticSeverity.Error, 'missing-sql-arg');
+            }
+        }
+        const runMcpRegex = /^\s*(?:var\s+[a-zA-Z_][a-zA-Z0-9_]*\s*=\s*)?run\s+mcp\b/i;
+        let mcpConfigLoadAttempted = false;
+        let mcpConfigError;
+        let mcpServerAliases;
+        const loadMcpAliases = () => {
+            if (mcpConfigLoadAttempted) {
+                return mcpServerAliases;
+            }
+            mcpConfigLoadAttempted = true;
+            try {
+                const config = (0, mcpConfig_1.loadNornMcpProjectConfig)(document.uri.fsPath);
+                mcpServerAliases = new Set(Object.keys(config.config.servers).map(alias => alias.toLowerCase()));
+            }
+            catch (error) {
+                mcpConfigError = error instanceof Error ? error.message : String(error);
+            }
+            return mcpServerAliases;
+        };
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i];
+            if (isCommentLine(line) || !runMcpRegex.test(line)) {
+                continue;
+            }
+            const parsedList = (0, sequenceRunner_1.parseRunMcpListCommand)(line);
+            const parsedCall = parsedList ? null : (0, sequenceRunner_1.parseRunMcpCallCommand)(line);
+            if (!parsedList && !parsedCall) {
+                continue;
+            }
+            const serverAlias = parsedList?.serverAlias ?? parsedCall.serverAlias;
+            const aliasStart = line.indexOf(serverAlias);
+            const aliasRange = new vscode.Range(new vscode.Position(i, Math.max(0, aliasStart)), new vscode.Position(i, Math.max(0, aliasStart) + serverAlias.length));
+            if (parsedCall?.error) {
+                const mcpStart = line.toLowerCase().indexOf('mcp');
+                const range = new vscode.Range(new vscode.Position(i, Math.max(0, mcpStart)), new vscode.Position(i, line.length));
+                pushNornDiagnostic(diagnostics, range, parsedCall.error, vscode.DiagnosticSeverity.Error, 'invalid-run-mcp');
+                continue;
+            }
+            const aliases = loadMcpAliases();
+            if (!aliases) {
+                pushNornDiagnostic(diagnostics, aliasRange, mcpConfigError || `Invalid ${nornConfig_1.NORN_CONFIG_FILENAME} mcp section.`, vscode.DiagnosticSeverity.Error, 'invalid-mcp-config');
+                continue;
+            }
+            if (!aliases.has(serverAlias.toLowerCase())) {
+                pushNornDiagnostic(diagnostics, aliasRange, `Server alias '${serverAlias}' was not found in ${nornConfig_1.NORN_CONFIG_FILENAME} mcp.servers.`, vscode.DiagnosticSeverity.Error, 'unknown-mcp-server');
+                continue;
+            }
+            if (parsedCall) {
+                const seenArgs = new Set();
+                for (const arg of parsedCall.args) {
+                    if (!arg.name) {
+                        continue;
+                    }
+                    const lowerName = arg.name.toLowerCase();
+                    const startCol = line.indexOf(arg.name);
+                    if (seenArgs.has(lowerName)) {
+                        const range = new vscode.Range(new vscode.Position(i, Math.max(0, startCol)), new vscode.Position(i, Math.max(0, startCol) + arg.name.length));
+                        pushNornDiagnostic(diagnostics, range, `Duplicate MCP parameter '${arg.name}' in tool call.`, vscode.DiagnosticSeverity.Error, 'duplicate-mcp-arg');
+                    }
+                    seenArgs.add(lowerName);
+                }
+            }
+        }
+        // Check for undefined API endpoints and header groups
+        // Match patterns like: GET EndpointName("arg") HeaderGroup
+        const apiRequestRegex = /^\s*(GET|POST|PUT|DELETE|PATCH|HEAD|OPTIONS)\s+([A-Z][a-zA-Z0-9_]*)(?:\([^)]*\))?(?:\s+([A-Z][a-zA-Z0-9_]*))?/;
+        // Match standalone header group on its own line inside a request block.
+        const standaloneHeaderGroupRegex = /^\s*([a-zA-Z_][a-zA-Z0-9_]*)\s*$/;
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i];
+            // Skip comment lines
+            if (isCommentLine(line)) {
+                continue;
+            }
+            // Strip inline comments before checking API request syntax
+            const lineWithoutComment = (0, stringUtils_1.stripInlineComment)(line);
+            // Check API request syntax
+            const apiMatch = lineWithoutComment.match(apiRequestRegex);
+            if (apiMatch) {
+                const endpointName = apiMatch[2];
+                const headerGroupName = apiMatch[3];
+                // Check if endpoint exists
+                if (!importedEndpoints.has(endpointName)) {
+                    const startCol = line.indexOf(endpointName);
+                    const range = new vscode.Range(new vscode.Position(i, startCol), new vscode.Position(i, startCol + endpointName.length));
+                    pushNornDiagnostic(diagnostics, range, `Undefined endpoint: '${endpointName}'. Import a .nornapi file that defines this endpoint.`, vscode.DiagnosticSeverity.Error, 'undefined-endpoint');
+                }
+                // Check if header group exists (if specified)
+                if (headerGroupName && !importedHeaderGroups.has(headerGroupName)) {
+                    const startCol = line.lastIndexOf(headerGroupName);
+                    const range = new vscode.Range(new vscode.Position(i, startCol), new vscode.Position(i, startCol + headerGroupName.length));
+                    pushNornDiagnostic(diagnostics, range, `Undefined header group: '${headerGroupName}'. Import a .nornapi file that defines this header group.`, vscode.DiagnosticSeverity.Error, 'undefined-header-group');
+                }
+            }
+            // Check standalone header group lines.
+            const standaloneMatch = lineWithoutComment.match(standaloneHeaderGroupRegex);
+            if (standaloneMatch && isInsideRequestBlock(lines, i)) {
+                const headerGroupName = standaloneMatch[1];
+                const shouldValidateAsHeaderGroup = importedHeaderGroups.has(headerGroupName) || /^[A-Z]/.test(headerGroupName);
+                // Only flag as undefined if we have some .nornapi imports (otherwise it might just be a typo or URL)
+                if (shouldValidateAsHeaderGroup && (importedEndpoints.size > 0 || importedHeaderGroups.size > 0)) {
+                    if (!importedHeaderGroups.has(headerGroupName)) {
+                        const startCol = line.indexOf(headerGroupName);
+                        const range = new vscode.Range(new vscode.Position(i, startCol), new vscode.Position(i, startCol + headerGroupName.length));
+                        pushNornDiagnostic(diagnostics, range, `Undefined header group: '${headerGroupName}'. Import a .nornapi file that defines this header group.`, vscode.DiagnosticSeverity.Error, 'undefined-header-group');
+                    }
+                }
+            }
+        }
+        // Check for JSON-like request body properties without surrounding { } object
+        const bodyMethods = new Set(['POST', 'PUT', 'PATCH']);
+        const requestStartRegex = /^\s*(?:var\s+[a-zA-Z_][a-zA-Z0-9_]*\s*=\s*)?(GET|POST|PUT|DELETE|PATCH|HEAD|OPTIONS)\s+/i;
+        const inlineHeaderRegex = /^([A-Za-z][A-Za-z0-9\-]*)\s*:\s*(.+)$/;
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i];
+            if (isCommentLine(line)) {
+                continue;
+            }
+            const lineWithoutComment = (0, stringUtils_1.stripInlineComment)(line).trim();
+            const requestMatch = lineWithoutComment.match(requestStartRegex);
+            if (!requestMatch) {
+                continue;
+            }
+            const method = requestMatch[1].toUpperCase();
+            if (!bodyMethods.has(method)) {
+                continue;
+            }
+            let requestContentType;
+            const afterMethod = lineWithoutComment.replace(requestStartRegex, '').trim();
+            const methodLineTokens = afterMethod.split(/\s+/).filter(t => t.length > 0);
+            for (const token of methodLineTokens) {
+                const cleanToken = token.replace(/[,)]+$/g, '');
+                const group = importedHeaderGroups.get(cleanToken)?.headerGroup;
+                if (group) {
+                    const headerValue = getHeaderValueCaseInsensitive(group.headers, 'Content-Type');
+                    if (headerValue) {
+                        requestContentType = headerValue.toLowerCase();
+                    }
+                }
+            }
+            let objectDepth = 0;
+            let hasReported = false;
+            let reachedBody = false;
+            const formBodyLines = [];
+            const jsonBodyLines = [];
+            for (let j = i + 1; j < lines.length; j++) {
+                const bodyLine = lines[j];
+                if (isCommentLine(bodyLine)) {
+                    continue;
+                }
+                const bodyLineWithoutComment = (0, stringUtils_1.stripInlineComment)(bodyLine);
+                const trimmedBodyLine = bodyLineWithoutComment.trim();
+                if (!trimmedBodyLine) {
+                    continue;
+                }
+                if (isRequestBodyBoundary(trimmedBodyLine)) {
+                    break;
+                }
+                if (!reachedBody) {
+                    const headerMatch = trimmedBodyLine.match(inlineHeaderRegex);
+                    if (headerMatch) {
+                        if (headerMatch[1].toLowerCase() === 'content-type') {
+                            requestContentType = headerMatch[2].trim().toLowerCase();
+                        }
+                        continue;
+                    }
+                    const headerGroup = importedHeaderGroups.get(trimmedBodyLine)?.headerGroup;
+                    if (headerGroup) {
+                        const headerValue = getHeaderValueCaseInsensitive(headerGroup.headers, 'Content-Type');
+                        if (headerValue) {
+                            requestContentType = headerValue.toLowerCase();
+                        }
+                        continue;
+                    }
+                }
+                reachedBody = true;
+                const isFormBody = (0, formUrlEncoded_1.isFormUrlEncodedContentType)(requestContentType);
+                if (isFormBody) {
+                    formBodyLines.push({ lineNumber: j, text: trimmedBodyLine });
+                    continue;
+                }
+                const startsJsonObject = trimmedBodyLine.startsWith('{');
+                if (!hasReported && looksLikeJsonPropertyLine(trimmedBodyLine) && objectDepth === 0 && !startsJsonObject) {
+                    const startCol = bodyLine.indexOf('"');
+                    const range = new vscode.Range(new vscode.Position(j, startCol >= 0 ? startCol : 0), new vscode.Position(j, bodyLine.length));
+                    pushNornDiagnostic(diagnostics, range, `Invalid JSON body: properties must be wrapped in '{' and '}'.`, vscode.DiagnosticSeverity.Error, 'invalid-json-body-missing-braces');
+                    hasReported = true;
+                }
+                if (isJsonContentType(requestContentType) ||
+                    jsonBodyLines.length > 0 ||
+                    trimmedBodyLine.startsWith('{') ||
+                    trimmedBodyLine.startsWith('[')) {
+                    jsonBodyLines.push({ lineNumber: j, text: trimmedBodyLine });
+                }
+                objectDepth += countChar(trimmedBodyLine, '{');
+                objectDepth -= countChar(trimmedBodyLine, '}');
+                if (objectDepth < 0) {
+                    objectDepth = 0;
+                }
+            }
+            if (formBodyLines.length > 0) {
+                const { errors } = (0, formUrlEncoded_1.parseFormUrlEncodedLines)(formBodyLines.map(line => line.text));
+                for (const error of errors) {
+                    const sourceLine = formBodyLines[error.lineIndex];
+                    if (!sourceLine) {
+                        continue;
+                    }
+                    const documentLine = lines[sourceLine.lineNumber];
+                    const startCol = documentLine.indexOf(error.line);
+                    const range = new vscode.Range(new vscode.Position(sourceLine.lineNumber, startCol >= 0 ? startCol : 0), new vscode.Position(sourceLine.lineNumber, documentLine.length));
+                    pushNornDiagnostic(diagnostics, range, `Invalid form body: ${error.message}`, vscode.DiagnosticSeverity.Error, 'invalid-form-urlencoded-body');
+                }
+            }
+            else if (!hasReported) {
+                validateJsonBodyLines(diagnostics, lines, jsonBodyLines);
+            }
+        }
+        // Find empty variable references {{}} or {{ }}
+        const emptyVarRegex = /\{\{\s*\}\}/g;
+        let emptyMatch;
+        while ((emptyMatch = emptyVarRegex.exec(text)) !== null) {
+            const startPos = document.positionAt(emptyMatch.index);
+            const lineNumber = startPos.line;
+            // Ignore empty variable references inside full-line comments
+            if (isCommentLine(lines[lineNumber])) {
+                continue;
+            }
+            const endPos = document.positionAt(emptyMatch.index + emptyMatch[0].length);
+            const range = new vscode.Range(startPos, endPos);
+            pushNornDiagnostic(diagnostics, range, `Empty variable reference`, vscode.DiagnosticSeverity.Error, 'empty-variable');
+        }
+        // Check for invalid variable assignments inside sequences
+        // Valid patterns:
+        // - var x = "string"  (quoted string)
+        // - var x = 123  (number)
+        // - var x = true/false/null  (literals)
+        // - var x = varName.path  (existing variable path)
+        // - var x = $1.body.id  (response capture)
+        // - var x = run ...  (script/json command)
+        // - var x = https://... (URL - for backward compat outside sequences)
+        const varAssignRegex = /^\s*var\s+([a-zA-Z_][a-zA-Z0-9_]*)\s*=\s*(.+)$/;
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i];
+            // Skip comment lines
+            if (isCommentLine(line)) {
+                continue;
+            }
+            // Strip inline comments before processing
+            const lineWithoutComment = (0, stringUtils_1.stripInlineComment)(line);
+            const match = lineWithoutComment.match(varAssignRegex);
+            if (match) {
+                const varName = match[1];
+                const valueExpr = match[2].trim();
+                const containingSeq = sequences.find(seq => i > seq.startLine && i < seq.endLine);
+                if (containingSeq && varName in envVariables) {
+                    const startCol = line.indexOf(varName);
+                    const range = new vscode.Range(new vscode.Position(i, startCol), new vscode.Position(i, startCol + varName.length));
+                    pushNornDiagnostic(diagnostics, range, `Local variable '${varName}' shadows environment variable '${varName}'. Use {{$env.${varName}}} to access the env value explicitly.`, vscode.DiagnosticSeverity.Warning, 'env-variable-shadowed');
+                }
+                // Skip valid patterns
+                // 1. Response capture: $1.path
+                if (/^\$\d+/.test(valueExpr)) {
+                    continue;
+                }
+                // 2. Run command: run bash, run js, run powershell, run readJson
+                if (/^run\s+/i.test(valueExpr)) {
+                    continue;
+                }
+                // 3. Quoted string: "..." or '...'
+                if ((valueExpr.startsWith('"') && valueExpr.endsWith('"')) ||
+                    (valueExpr.startsWith("'") && valueExpr.endsWith("'"))) {
+                    continue;
+                }
+                // 4. Number
+                if (/^-?\d+(\.\d+)?$/.test(valueExpr)) {
+                    continue;
+                }
+                // 5. Boolean/null
+                if (/^(true|false|null)$/i.test(valueExpr)) {
+                    continue;
+                }
+                // 6. URL (common case outside sequences)
+                if (/^https?:\/\//.test(valueExpr)) {
+                    continue;
+                }
+                // 7. HTTP request: GET/POST/etc followed by URL or endpoint
+                const httpRequestMatch = valueExpr.match(/^(GET|POST|PUT|DELETE|PATCH|HEAD|OPTIONS)\s+(.+)$/i);
+                if (httpRequestMatch) {
+                    const afterMethod = httpRequestMatch[2].trim();
+                    // Check if it's a URL (starts with http, https, or {{ - also handle quoted URLs)
+                    if (/^["']?(https?:\/\/|\{\{)/.test(afterMethod)) {
+                        // It's a URL - skip validation
+                        continue;
+                    }
+                    // It might be an endpoint name: EndpointName(params) HeaderGroup1 HeaderGroup2
+                    const endpointMatch = afterMethod.match(/^([a-zA-Z_][a-zA-Z0-9_]*)(?:\([^)]*\))?(.*)$/);
+                    if (endpointMatch) {
+                        const endpointName = endpointMatch[1];
+                        const afterEndpoint = endpointMatch[2]?.trim() || '';
+                        // Validate endpoint exists
+                        if (importedEndpoints.size > 0 && !importedEndpoints.has(endpointName)) {
+                            const endpointStart = line.indexOf(endpointName, line.indexOf('='));
+                            const range = new vscode.Range(new vscode.Position(i, endpointStart), new vscode.Position(i, endpointStart + endpointName.length));
+                            pushNornDiagnostic(diagnostics, range, `Undefined endpoint: '${endpointName}'. Import a .nornapi file that defines this endpoint.`, vscode.DiagnosticSeverity.Error, 'undefined-endpoint');
+                        }
+                        // Validate header groups
+                        if (afterEndpoint) {
+                            // Strip retry and backoff options before checking header groups
+                            // Use \b word boundaries instead of \s+ since afterEndpoint is already trimmed
+                            const afterEndpointClean = afterEndpoint
+                                .replace(/\bretry\s+\d+/gi, '')
+                                .replace(/\bbackoff\s+\d+(?:\.\d+)?\s*(?:s|ms|seconds?|milliseconds?)?/gi, '');
+                            const headerGroupNames = afterEndpointClean.split(/\s+/).filter(n => n);
+                            for (const hgName of headerGroupNames) {
+                                if (!importedHeaderGroups.has(hgName)) {
+                                    const hgStart = line.lastIndexOf(hgName);
+                                    const range = new vscode.Range(new vscode.Position(i, hgStart), new vscode.Position(i, hgStart + hgName.length));
+                                    pushNornDiagnostic(diagnostics, range, `Undefined header group: '${hgName}'. Import a .nornapi file that defines this header group.`, vscode.DiagnosticSeverity.Error, 'undefined-header-group');
+                                }
+                            }
+                        }
+                    }
+                    continue;
+                }
+                // 8. Variable path: must be an existing variable
+                const varPathMatch = valueExpr.match(/^([a-zA-Z_][a-zA-Z0-9_]*)((?:\.[a-zA-Z_][a-zA-Z0-9_]*|\[\d+\])*)$/);
+                if (varPathMatch) {
+                    const refVarName = varPathMatch[1];
+                    // Check if this assignment is inside a sequence
+                    let isValid = false;
+                    if (containingSeq) {
+                        // Inside sequence: check global vars + local sequence vars + params
+                        const localVars = getSequenceLocalVariables(containingSeq.content, containingSeq.parameters);
+                        isValid = refVarName in globalVariables || localVars.has(refVarName);
+                    }
+                    else {
+                        // Outside sequences: only global variables
+                        isValid = refVarName in globalVariables;
+                    }
+                    if (isValid) {
+                        continue;
+                    }
+                    // Variable not defined - show error
+                    const valueStart = line.indexOf('=') + 1;
+                    const valueStartTrimmed = valueStart + (line.substring(valueStart).length - line.substring(valueStart).trimStart().length);
+                    const range = new vscode.Range(new vscode.Position(i, valueStartTrimmed), new vscode.Position(i, valueStartTrimmed + refVarName.length));
+                    pushNornDiagnostic(diagnostics, range, `Undefined variable: '${refVarName}'. Use quotes for string literals: var ${varName} = "${valueExpr}"`, vscode.DiagnosticSeverity.Error, 'undefined-var-reference');
+                    continue;
+                }
+                // If we get here, it's an invalid expression (has spaces, not quoted, not valid pattern)
+                const valueStart = line.indexOf('=') + 1;
+                const valueStartTrimmed = valueStart + (line.substring(valueStart).length - line.substring(valueStart).trimStart().length);
+                const range = new vscode.Range(new vscode.Position(i, valueStartTrimmed), new vscode.Position(i, line.length));
+                pushNornDiagnostic(diagnostics, range, `Invalid variable value. Use quotes for strings: var ${varName} = "${valueExpr}"`, vscode.DiagnosticSeverity.Error, 'invalid-var-value');
+            }
+        }
+        // Find all variable references {{variableName}}, {{variableName.path}}, or {{$env.variableName}}
+        const variableRefRegex = /\{\{(\$env|[a-zA-Z_][a-zA-Z0-9_]*)((?:\.[a-zA-Z_][a-zA-Z0-9_]*|\[\d+\])*)\}\}/g;
+        let match;
+        while ((match = variableRefRegex.exec(text)) !== null) {
+            const varName = match[1];
+            const pathPart = match[2] || '';
+            const startPos = document.positionAt(match.index);
+            const lineNumber = startPos.line;
+            // Skip if this line is a comment
+            if (isCommentLine(lines[lineNumber])) {
+                continue;
+            }
+            // Check if this reference is inside a sequence
+            const containingSequence = sequences.find(seq => lineNumber > seq.startLine && lineNumber < seq.endLine);
+            let isValid = false;
+            let diagnosticMessage;
+            if (varName === '$env') {
+                const envVarName = getEnvScopedBaseName(pathPart);
+                if (!envVarName) {
+                    diagnosticMessage = `Environment variable references must use {{$env.name}} syntax.`;
+                }
+                else if (!environmentVariableNames.has(envVarName)) {
+                    diagnosticMessage = `Undefined environment variable: '${envVarName}'`;
+                }
+                else {
+                    isValid = true;
+                }
+            }
+            if (!isValid && !diagnosticMessage && containingSequence) {
+                // Inside a sequence: check global vars + local sequence vars + params
+                const localVars = getSequenceLocalVariables(containingSequence.content, containingSequence.parameters);
+                isValid = varName in globalVariables || environmentVariableNames.has(varName) || localVars.has(varName);
+            }
+            else if (!isValid && !diagnosticMessage) {
+                // Outside sequences: only global variables are available
+                isValid = varName in globalVariables || environmentVariableNames.has(varName);
+            }
+            if (!isValid) {
+                const endPos = document.positionAt(match.index + match[0].length);
+                const range = new vscode.Range(startPos, endPos);
+                pushNornDiagnostic(diagnostics, range, diagnosticMessage || `Undefined variable: '${varName}'`, vscode.DiagnosticSeverity.Error, diagnosticMessage ? 'invalid-env-variable-reference' : 'undefined-variable');
+            }
+        }
+        // Check bare/path variable reads that are not wrapped in {{...}}.
+        // Only validate the base identifier so dynamic JSON paths remain valid.
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i];
+            if (isCommentLine(line)) {
+                continue;
+            }
+            const lineWithoutComment = (0, stringUtils_1.stripInlineComment)(line);
+            const availableVars = getAvailableVariablesForLine(sequences, globalVariables, i);
+            const nonEnvironmentVariableNames = getAvailableNonEnvironmentVariablesForLine(sequences, fileLevelVariables, i);
+            const propertyAssignment = (0, jsonFileReader_1.parsePropertyAssignment)(lineWithoutComment);
+            if (propertyAssignment && !availableVars.has(propertyAssignment.varName)) {
+                const startCol = line.indexOf(propertyAssignment.varName);
+                addUndefinedBaseVariableDiagnostic(diagnostics, i, startCol, propertyAssignment.varName);
+            }
+            const assertMatch = lineWithoutComment.match(/^\s*assert\s+/i);
+            if (assertMatch) {
+                const parsed = (0, assertionRunner_1.parseAssertCommand)(lineWithoutComment);
+                if (parsed) {
+                    const expressions = [parsed.leftExpr];
+                    if (parsed.rightExpr && parsed.operator !== 'isType') {
+                        expressions.push(parsed.rightExpr);
+                    }
+                    let searchFrom = assertMatch[0].length;
+                    for (const expression of expressions) {
+                        const expressionStart = lineWithoutComment.indexOf(expression, searchFrom);
+                        if (expressionStart < 0) {
+                            continue;
+                        }
+                        addBareTemplateExpressionDiagnostic(diagnostics, expression, expressionStart, i, environmentVariableNames, nonEnvironmentVariableNames);
+                        addUndefinedVariableReadDiagnostic(diagnostics, expression, expressionStart, i, availableVars);
+                        searchFrom = expressionStart + expression.length;
+                    }
+                }
+                continue;
+            }
+            const ifMatch = lineWithoutComment.match(/^\s*if\s+(.+)$/i);
+            if (ifMatch) {
+                const parsed = (0, assertionRunner_1.parseAssertCommand)(`assert ${ifMatch[1]}`);
+                if (parsed) {
+                    const expressions = [parsed.leftExpr];
+                    if (parsed.rightExpr && parsed.operator !== 'isType') {
+                        expressions.push(parsed.rightExpr);
+                    }
+                    let searchFrom = lineWithoutComment.indexOf(ifMatch[1]);
+                    for (const expression of expressions) {
+                        const expressionStart = lineWithoutComment.indexOf(expression, searchFrom);
+                        if (expressionStart < 0) {
+                            continue;
+                        }
+                        addBareTemplateExpressionDiagnostic(diagnostics, expression, expressionStart, i, environmentVariableNames, nonEnvironmentVariableNames);
+                        addUndefinedVariableReadDiagnostic(diagnostics, expression, expressionStart, i, availableVars);
+                        searchFrom = expressionStart + expression.length;
+                    }
+                }
+                continue;
+            }
+            const returnMatch = lineWithoutComment.match(/^\s*return\s+(.+)$/i);
+            if (returnMatch) {
+                const returnContentStart = lineWithoutComment.indexOf(returnMatch[1]);
+                for (const part of splitCommaSeparatedExpressions(returnMatch[1])) {
+                    addUndefinedVariableReadDiagnostic(diagnostics, part.text, returnContentStart + part.start, i, availableVars);
+                }
+            }
+        }
+        // Conservative syntax diagnostics for malformed/unknown .norn statements.
+        // Purpose: catch high-confidence typos early (e.g. method/keyword typos) without noisy squiggles while typing.
+        const httpMethods = ['GET', 'POST', 'PUT', 'DELETE', 'PATCH', 'HEAD', 'OPTIONS'];
+        const commandKeywords = ['sequence', 'test', 'assert', 'print', 'run', 'import', 'return', 'wait', 'if', 'endif', 'foreach'];
+        const lineHasDiagnostic = (lineNumber) => diagnostics.some(d => d.range.start.line === lineNumber);
+        for (let i = 0; i < lines.length; i++) {
+            const originalLine = lines[i];
+            if (isCommentLine(originalLine)) {
+                continue;
+            }
+            const trimmed = (0, stringUtils_1.stripInlineComment)(originalLine).trim();
+            if (!trimmed) {
+                continue;
+            }
+            if (lineHasDiagnostic(i)) {
+                continue;
+            }
+            if (/^end\s+sequence\b/i.test(trimmed) && !/^end\s+sequence$/i.test(trimmed)) {
+                const startCol = originalLine.toLowerCase().indexOf('end sequence');
+                const range = new vscode.Range(new vscode.Position(i, Math.max(0, startCol)), new vscode.Position(i, originalLine.length));
+                pushNornDiagnostic(diagnostics, range, `Invalid 'end sequence' syntax. Use exactly: end sequence`, vscode.DiagnosticSeverity.Error, 'invalid-end-sequence');
+                continue;
+            }
+            if ((/^end\s+if\b/i.test(trimmed) || /^endif\b/i.test(trimmed)) && !/^(?:end\s+if|endif)$/i.test(trimmed)) {
+                const marker = /^endif\b/i.test(trimmed) ? 'endif' : 'end if';
+                const startCol = originalLine.toLowerCase().indexOf(marker);
+                const range = new vscode.Range(new vscode.Position(i, Math.max(0, startCol)), new vscode.Position(i, originalLine.length));
+                pushNornDiagnostic(diagnostics, range, `Invalid '${marker}' syntax. Use exactly: end if (or endif)`, vscode.DiagnosticSeverity.Error, 'invalid-end-if');
+                continue;
+            }
+            // Sequence declaration starts with a known keyword, so validate explicitly for extra junk text.
+            if (/^(?:test\s+)?sequence\b/i.test(trimmed) && !isValidSequenceDeclarationLine(trimmed)) {
+                // Allow obvious in-progress states while typing.
+                if (!/^(?:test\s+)?sequence\s*$/i.test(trimmed)) {
+                    const seqWord = /^\s*test\s+sequence\b/i.test(originalLine) ? 'test sequence' : 'sequence';
+                    const startCol = originalLine.toLowerCase().indexOf(seqWord);
+                    const range = new vscode.Range(new vscode.Position(i, Math.max(0, startCol)), new vscode.Position(i, originalLine.length));
+                    pushNornDiagnostic(diagnostics, range, `Invalid sequence declaration. Use: ${seqWord} Name or ${seqWord} Name(param1, param2)`, vscode.DiagnosticSeverity.Error, 'invalid-sequence-declaration');
+                    continue;
+                }
+            }
+            if (/^wait\b/i.test(trimmed) && !isLikelyPartialCommand(trimmed) && !isValidWaitCommandLine(trimmed)) {
+                const startCol = originalLine.toLowerCase().indexOf('wait');
+                const range = new vscode.Range(new vscode.Position(i, Math.max(0, startCol)), new vscode.Position(i, originalLine.length));
+                pushNornDiagnostic(diagnostics, range, `Invalid wait command. Use: wait 2s, wait 500ms, or wait 1.5s`, vscode.DiagnosticSeverity.Error, 'invalid-wait-command');
+                continue;
+            }
+            if (/^(?:var\s+[a-zA-Z_][a-zA-Z0-9_]*\s*=\s*)?run\b/i.test(trimmed) &&
+                !isLikelyPartialCommand(trimmed) &&
+                !isValidRunLikeCommandLine(trimmed)) {
+                const runIndex = originalLine.toLowerCase().indexOf('run');
+                const range = new vscode.Range(new vscode.Position(i, Math.max(0, runIndex)), new vscode.Position(i, originalLine.length));
+                let message = `Invalid run command syntax.`;
+                if (/\bretry\s+\D/i.test(trimmed)) {
+                    message = `Invalid retry syntax in run command. Use: run Name retry 3 (optional backoff 500 ms).`;
+                }
+                else if (/\bbackoff\s+\D/i.test(trimmed)) {
+                    message = `Invalid backoff syntax in run command. Use: backoff 500 ms (or 1.5s).`;
+                }
+                else if (/\bheaders?\b/i.test(trimmed)) {
+                    message = `Unexpected token after run command. 'headers' is not valid in run syntax.`;
+                }
+                else {
+                    message = `Invalid run command. Use a named request/sequence, script command, run sql, or run mcp list/call.`;
+                }
+                pushNornDiagnostic(diagnostics, range, message, vscode.DiagnosticSeverity.Error, 'invalid-run-command');
+                continue;
+            }
+            // Exact method with no URL: high-confidence error
+            const missingUrlMatch = trimmed.match(/^(?:var\s+[a-zA-Z_][a-zA-Z0-9_]*\s*=\s*)?(GET|POST|PUT|DELETE|PATCH|HEAD|OPTIONS)\s*$/i);
+            if (missingUrlMatch) {
+                // Suppress while typing a likely partial lowercase flow such as "get" without URL? No, exact method is actionable.
+                const method = missingUrlMatch[1].toUpperCase();
+                const methodIndex = originalLine.toUpperCase().indexOf(method);
+                const range = new vscode.Range(new vscode.Position(i, Math.max(0, methodIndex)), new vscode.Position(i, originalLine.length));
+                pushNornDiagnostic(diagnostics, range, `Request is missing a URL after ${method}. Use: ${method} https://api.example.com/path`, vscode.DiagnosticSeverity.Error, 'request-missing-url');
+                continue;
+            }
+            // Regular request method line with suspicious trailing tokens after URL.
+            // This catches invalid combinations like: GET "https://..." headers or GET {{baseUrl}} Peter
+            const requestLineMatch = trimmed.match(/^(?:var\s+[a-zA-Z_][a-zA-Z0-9_]*\s*=\s*)?(GET|POST|PUT|DELETE|PATCH|HEAD|OPTIONS)\s+(.+)$/i);
+            if (requestLineMatch) {
+                const { urlToken, tail } = splitRequestUrlAndTail(requestLineMatch[2]);
+                if (urlToken && tail) {
+                    const tailWithoutRetry = stripRetryBackoffTokens(tail);
+                    if (tailWithoutRetry) {
+                        const tailTokens = tailWithoutRetry.split(/\s+/).filter(Boolean);
+                        const unknownTokens = tailTokens.filter(token => !importedHeaderGroups.has(token));
+                        if (unknownTokens.length > 0) {
+                            const firstUnknown = unknownTokens[0];
+                            const startCol = originalLine.indexOf(firstUnknown);
+                            const range = new vscode.Range(new vscode.Position(i, Math.max(0, startCol)), new vscode.Position(i, Math.max(0, startCol) + firstUnknown.length));
+                            const lower = firstUnknown.toLowerCase();
+                            let message = `Unexpected token '${firstUnknown}' after request URL.`;
+                            if (lower === 'headers' || lower === 'header') {
+                                message = `Invalid request syntax: use a header group name after the URL (e.g. Json), not the keyword '${firstUnknown}'.`;
+                            }
+                            else if (/^[A-Z][a-zA-Z0-9_]*$/.test(firstUnknown) || /^[a-zA-Z_][a-zA-Z0-9_]*$/.test(firstUnknown)) {
+                                if (importedHeaderGroups.size > 0) {
+                                    message = `Unknown header group '${firstUnknown}' after request URL. Import a .nornapi file that defines it.`;
+                                }
+                                else {
+                                    message = `Unexpected token '${firstUnknown}' after request URL. If this is a header group, import a .nornapi file and use a defined group name.`;
+                                }
+                            }
+                            pushNornDiagnostic(diagnostics, range, message, vscode.DiagnosticSeverity.Error, 'invalid-request-trailing-token');
+                            continue;
+                        }
+                    }
+                }
+            }
+            // HTTP method typo detection (e.g. POTS/GE T)
+            const methodLikeMatch = trimmed.match(/^(?:var\s+[a-zA-Z_][a-zA-Z0-9_]*\s*=\s*)?([A-Za-z]{2,10})\b/);
+            if (methodLikeMatch) {
+                const token = methodLikeMatch[1];
+                const upperToken = token.toUpperCase();
+                if (!httpMethods.includes(upperToken)) {
+                    const suggestedMethod = suggestClosestKeyword(upperToken, httpMethods);
+                    // Only flag if it looks like an uppercase/loud request method typo and the line isn't clearly another valid statement.
+                    const looksLikeMethodIntent = token === upperToken || httpMethods.some(m => m.startsWith(upperToken));
+                    if (suggestedMethod && looksLikeMethodIntent && !isKnownNornCommandOrStructureStart(trimmed)) {
+                        const startCol = originalLine.indexOf(token);
+                        const range = new vscode.Range(new vscode.Position(i, Math.max(0, startCol)), new vscode.Position(i, Math.max(0, startCol) + token.length));
+                        pushNornDiagnostic(diagnostics, range, `Unknown HTTP method '${token}'. Did you mean '${suggestedMethod}'?`, vscode.DiagnosticSeverity.Error, 'invalid-http-method');
+                        continue;
+                    }
+                }
+            }
+            if (isLikelyPartialCommand(trimmed)) {
+                continue;
+            }
+            const allowAsRequestBodyValue = isLikelyRequestBodyValueLine(trimmed) && isInsideRequestBlock(lines, i);
+            // Unknown command typo detection for the first word (outside known request/body/header structures)
+            if (!allowAsRequestBodyValue && !isKnownNornCommandOrStructureStart(trimmed)) {
+                const firstTokenMatch = trimmed.match(/^([a-zA-Z_][a-zA-Z0-9_-]*)/);
+                if (firstTokenMatch) {
+                    const firstToken = firstTokenMatch[1];
+                    const suggestion = suggestClosestKeyword(firstToken, commandKeywords);
+                    const startCol = originalLine.indexOf(firstToken);
+                    const range = new vscode.Range(new vscode.Position(i, Math.max(0, startCol)), new vscode.Position(i, Math.max(0, startCol) + firstToken.length));
+                    pushNornDiagnostic(diagnostics, range, suggestion
+                        ? `Unknown command '${firstToken}'. Did you mean '${suggestion}'?`
+                        : `Unrecognized statement. Norn couldn't parse this line.`, vscode.DiagnosticSeverity.Error, suggestion ? 'unknown-command-typo' : 'unknown-statement');
+                }
+            }
+        }
+        // Check for bare text in print statements that isn't a string, variable, or keyword
+        const printCommandRegex = /^\s*print\s+(.+)$/i;
+        const validKeywords = new Set(['true', 'false', 'null']);
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i];
+            // Skip comment lines
+            if (isCommentLine(line)) {
+                continue;
+            }
+            // Strip inline comments before processing print statement
+            const lineWithoutComment = (0, stringUtils_1.stripInlineComment)(line);
+            const printMatch = lineWithoutComment.match(printCommandRegex);
+            if (!printMatch) {
+                continue;
+            }
+            const printContent = printMatch[1];
+            const printStartCol = line.indexOf(printContent);
+            // Check if this print is inside a sequence
+            const containingSeq = sequences.find(seq => i > seq.startLine && i < seq.endLine);
+            // Get available variables for this scope
+            let availableVars;
+            if (containingSeq) {
+                const localVars = getSequenceLocalVariables(containingSeq.content, containingSeq.parameters);
+                availableVars = new Set([...Object.keys(globalVariables), ...localVars]);
+            }
+            else {
+                availableVars = new Set(Object.keys(globalVariables));
+            }
+            // Parse print content into tokens (respecting quoted strings and operators)
+            const tokens = tokenizePrintContent(printContent);
+            // Check for missing concatenation operators between tokens
+            for (let t = 0; t < tokens.length - 1; t++) {
+                const currentToken = tokens[t];
+                const nextToken = tokens[t + 1];
+                // Skip if current token is an operator
+                if (/^[+\-*/|&<>=!]+$/.test(currentToken.text)) {
+                    continue;
+                }
+                // If next token is not an operator, we're missing concatenation
+                if (!/^[+\-*/|&<>=!]+$/.test(nextToken.text)) {
+                    // Calculate position between the two tokens
+                    const errorStartCol = printStartCol + currentToken.start + currentToken.text.length;
+                    const errorEndCol = printStartCol + nextToken.start;
+                    const range = new vscode.Range(new vscode.Position(i, errorStartCol), new vscode.Position(i, errorEndCol));
+                    pushNornDiagnostic(diagnostics, range, `Missing concatenation operator '+' between '${currentToken.text}' and '${nextToken.text}'`, vscode.DiagnosticSeverity.Error, 'missing-concatenation');
+                }
+            }
+            for (const token of tokens) {
+                // Skip operators (+, -, etc.)
+                if (/^[+\-*/|&<>=!]+$/.test(token.text)) {
+                    continue;
+                }
+                // Skip quoted strings
+                if ((token.text.startsWith('"') && token.text.endsWith('"')) ||
+                    (token.text.startsWith("'") && token.text.endsWith("'"))) {
+                    continue;
+                }
+                // Skip numbers
+                if (/^-?\d+(\.\d+)?$/.test(token.text)) {
+                    continue;
+                }
+                // Skip keywords (true, false, null)
+                if (validKeywords.has(token.text.toLowerCase())) {
+                    continue;
+                }
+                // Skip variable references {{var}}
+                if (/^\{\{.+\}\}$/.test(token.text)) {
+                    continue;
+                }
+                // Check if it's a valid variable (with optional path)
+                const varPathMatch = token.text.match(/^([a-zA-Z_][a-zA-Z0-9_]*)((?:\.[a-zA-Z_][a-zA-Z0-9_]*|\[\d+\])*)$/);
+                if (varPathMatch) {
+                    const refVarName = varPathMatch[1];
+                    if (availableVars.has(refVarName)) {
+                        continue;
+                    }
+                    const tokenStartCol = printStartCol + token.start;
+                    const range = new vscode.Range(new vscode.Position(i, tokenStartCol), new vscode.Position(i, tokenStartCol + refVarName.length));
+                    pushNornDiagnostic(diagnostics, range, `Undefined variable: '${refVarName}'. Use quotes for string literals: "${token.text}"`, vscode.DiagnosticSeverity.Error, 'undefined-print-variable');
+                    continue;
+                }
+                // Check if it looks like a plain text word (not a valid identifier pattern)
+                // Flag words that look like they should be quoted
+                if (/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(token.text)) {
+                    // It's a valid identifier but not a defined variable - flag it
+                    const tokenStartCol = printStartCol + token.start;
+                    const range = new vscode.Range(new vscode.Position(i, tokenStartCol), new vscode.Position(i, tokenStartCol + token.text.length));
+                    pushNornDiagnostic(diagnostics, range, `Undefined variable: '${token.text}'. Use quotes for string literals: "${token.text}"`, vscode.DiagnosticSeverity.Error, 'undefined-print-variable');
+                }
+                else if (!/^[a-zA-Z_]/.test(token.text) === false && !varPathMatch) {
+                    // Some other bare text that doesn't look like anything valid
+                    const tokenStartCol = printStartCol + token.start;
+                    const range = new vscode.Range(new vscode.Position(i, tokenStartCol), new vscode.Position(i, tokenStartCol + token.text.length));
+                    pushNornDiagnostic(diagnostics, range, `Invalid expression: '${token.text}'. Use quotes for string literals.`, vscode.DiagnosticSeverity.Error, 'invalid-print-expression');
+                }
+            }
+        }
+        this.diagnosticCollection.set(document.uri, diagnostics);
+    }
+    /**
+     * Update diagnostics for .nornapi files
+     */
+    updateNornapiDiagnostics(document) {
+        const diagnostics = [];
+        const lines = document.getText().split('\n');
+        const httpMethods = ['GET', 'POST', 'PUT', 'DELETE', 'PATCH', 'HEAD', 'OPTIONS'];
+        const variableContext = getNornapiVariableDiagnosticContext(document.uri.fsPath);
+        let inEndpointsBlock = false;
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i];
+            const lineWithoutComment = (0, stringUtils_1.stripInlineComment)(line);
+            const trimmed = lineWithoutComment.trim();
+            // Skip empty lines/comments
+            if (trimmed === '' || trimmed.startsWith('#')) {
+                continue;
+            }
+            addNornapiPlaceholderDiagnostics(diagnostics, i, line, lineWithoutComment, 0, variableContext, false);
+            // Track endpoints block state
+            if (/^endpoints$/i.test(trimmed)) {
+                inEndpointsBlock = true;
+                continue;
+            }
+            if (/^end\s+endpoints$/i.test(trimmed)) {
+                inEndpointsBlock = false;
+                continue;
+            }
+            if (!inEndpointsBlock) {
+                continue;
+            }
+            // Valid endpoint declaration: Name: METHOD path
+            const validEndpoint = trimmed.match(/^([a-zA-Z_][a-zA-Z0-9_]*)\s*:\s*(GET|POST|PUT|DELETE|PATCH|HEAD|OPTIONS)\s+(.+)$/i);
+            if (validEndpoint) {
+                const endpointPath = validEndpoint[3];
+                const pathStart = line.indexOf(endpointPath);
+                addNornapiPlaceholderDiagnostics(diagnostics, i, line, endpointPath, pathStart >= 0 ? pathStart : 0, variableContext, true);
+                continue;
+            }
+            const endpointMatch = trimmed.match(/^([a-zA-Z_][a-zA-Z0-9_]*)\s*:\s*(.*)$/);
+            if (!endpointMatch) {
+                continue;
+            }
+            const endpointName = endpointMatch[1];
+            const rhs = endpointMatch[2].trim();
+            const colonIndex = line.indexOf(':');
+            const valueStart = colonIndex >= 0 ? colonIndex + 1 : 0;
+            const valueRange = new vscode.Range(new vscode.Position(i, Math.max(0, valueStart)), new vscode.Position(i, line.length));
+            // While typing: "Name:" or "Name: G" should not error yet
+            if (rhs === '') {
+                continue;
+            }
+            const firstToken = rhs.split(/\s+/)[0];
+            const upperFirstToken = firstToken.toUpperCase();
+            const isPartialMethod = httpMethods.some(m => m.startsWith(upperFirstToken));
+            if (!rhs.includes(' ') && isPartialMethod) {
+                continue;
+            }
+            if (httpMethods.includes(upperFirstToken) && !rhs.includes(' ')) {
+                pushNornDiagnostic(diagnostics, valueRange, `Endpoint '${endpointName}' is missing a URL/path after method. Use: ${endpointName}: ${upperFirstToken} /path`, vscode.DiagnosticSeverity.Error, 'missing-endpoint-path');
+                continue;
+            }
+            pushNornDiagnostic(diagnostics, valueRange, `Endpoint '${endpointName}' is missing HTTP method. Use: ${endpointName}: GET /path`, vscode.DiagnosticSeverity.Error, 'missing-endpoint-method');
+        }
+        this.diagnosticCollection.set(document.uri, diagnostics);
+    }
+    /**
+     * Update diagnostics for .nornenv files
+     */
+    updateNornenvDiagnostics(document) {
+        const diagnostics = [];
+        const text = document.getText();
+        const lines = text.split('\n');
+        const templateDeclarations = [];
+        const sections = [];
+        const parentReferences = [];
+        let currentSection;
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i];
+            const trimmed = line.trim();
+            // Skip comments and empty lines
+            if (trimmed === '' || trimmed.startsWith('#')) {
+                continue;
+            }
+            const section = parseNornenvSectionForDiagnostics(line, i);
+            if (section) {
+                sections.push(section);
+                parentReferences.push(...getNornenvParentReferencesForDiagnostics(line, section));
+                currentSection = { kind: section.kind, name: section.name };
+            }
+            const templateDeclaration = getNornenvTemplateDeclarationForDiagnostics(line, i, currentSection);
+            if (templateDeclaration) {
+                templateDeclarations.push(templateDeclaration);
+            }
+            // Check for invalid "secret var" pattern
+            const secretVarMatch = trimmed.match(/^(secret)\s+(var)\b\s*/i);
+            if (secretVarMatch) {
+                const varStart = line.indexOf('var', line.indexOf('secret') + 6);
+                const range = new vscode.Range(new vscode.Position(i, varStart), new vscode.Position(i, varStart + 3));
+                pushNornDiagnostic(diagnostics, range, `Invalid syntax: 'var' is not allowed after 'secret'. Use 'secret variableName = value'.`, vscode.DiagnosticSeverity.Error, 'invalid-secret-var');
+                continue;
+            }
+            const encryptedSecretMatch = trimmed.match(/^secret\s+(?:connectionString\s+([a-zA-Z_][a-zA-Z0-9_]*)|([a-zA-Z_][a-zA-Z0-9_]*))\s*=\s*(ENC\[.+)$/i);
+            if (encryptedSecretMatch) {
+                const encryptedValue = encryptedSecretMatch[3].trim();
+                if (encryptedValue.endsWith(']')) {
+                    const parsed = (0, crypto_1.parseEncryptedSecretValue)(encryptedValue);
+                    if (!parsed.ok) {
+                        const range = new vscode.Range(new vscode.Position(i, 0), new vscode.Position(i, line.length));
+                        pushNornDiagnostic(diagnostics, range, parsed.error, vscode.DiagnosticSeverity.Error, 'invalid-encrypted-secret');
+                        continue;
+                    }
+                }
+            }
+            // Check for valid patterns - if none match, it's an error
+            const validPatterns = [
+                /^\[(?:env|template):[a-zA-Z_][a-zA-Z0-9_-]*(?:\s+extends\s+[a-zA-Z_][a-zA-Z0-9_-]*(?:\s*,\s*[a-zA-Z_][a-zA-Z0-9_-]*)*)?\]$/, // Environment/template section
+                /^connectionString\s+[a-zA-Z_][a-zA-Z0-9_]*\s*=\s*.+$/, // Complete connection string declaration
+                /^secret\s+connectionString\s+[a-zA-Z_][a-zA-Z0-9_]*\s*=\s*.+$/, // Complete secret connection string declaration
+                /^(secret|var)\s+[a-zA-Z_][a-zA-Z0-9_]*\s*=\s*.+$/, // Complete declaration
+                /^connectionString\s*$/, // Just keyword (while typing)
+                /^connectionString\s+[a-zA-Z_][a-zA-Z0-9_]*\s*$/, // Keyword + profile (while typing)
+                /^connectionString\s+[a-zA-Z_][a-zA-Z0-9_]*\s*=\s*$/, // Keyword + profile + = (while typing)
+                /^secret\s+connectionString\s*$/, // secret connectionString while typing
+                /^secret\s+connectionString\s+[a-zA-Z_][a-zA-Z0-9_]*\s*$/, // secret connectionString + profile
+                /^secret\s+connectionString\s+[a-zA-Z_][a-zA-Z0-9_]*\s*=\s*$/, // secret connectionString + profile + =
+                /^(secret|var)\s*$/, // Just keyword (while typing)
+                /^(secret|var)\s+[a-zA-Z_][a-zA-Z0-9_]*\s*$/, // Keyword + name (while typing)
+                /^(secret|var)\s+[a-zA-Z_][a-zA-Z0-9_]*\s*=\s*$/, // Keyword + name + = (while typing)
+                /^import\s+["']?.+["']?\s*$/, // Complete import statement
+                /^import\s*$/, // Just keyword (while typing)
+                /^import\s+$/, // Keyword + space (while typing)
+            ];
+            const isValid = validPatterns.some(pattern => pattern.test(trimmed));
+            if (!isValid) {
+                const range = new vscode.Range(new vscode.Position(i, 0), new vscode.Position(i, line.length));
+                pushNornDiagnostic(diagnostics, range, `Invalid syntax. Expected: 'connectionString profile = value', 'secret connectionString profile = value', 'var name = value', 'secret name = value', 'import "path"', '[env:name]', or '[template:name]'.`, vscode.DiagnosticSeverity.Error, 'invalid-nornenv-syntax');
+            }
+        }
+        const config = (0, environmentParser_1.parseEnvFile)(text, document.uri.scheme === 'file' ? document.uri.fsPath : undefined);
+        let resolvedConfig = config;
+        let importErrors = [];
+        // --- Import validation ---
+        // Only run import checks if the document is saved to disk (has a file URI)
+        if (document.uri.scheme === 'file') {
+            const filePath = document.uri.fsPath;
+            if (config.imports.length > 0) {
+                // Resolve imports and check for errors (duplicates, circular, missing)
+                const result = (0, environmentParser_1.resolveNornenvImports)(config, path.dirname(filePath), filePath, (p) => fs.readFileSync(p, 'utf-8'));
+                resolvedConfig = result.config;
+                importErrors = result.errors;
+                for (const err of importErrors) {
+                    // Find the relevant line for the error
+                    let errorLine = err.line;
+                    // If line is -1 (duplicate from merge), find the import line that caused it
+                    if (errorLine === -1) {
+                        // For errors about a specific imported file, place on that import line
+                        const importLine = config.imports.find(imp => {
+                            const resolvedPath = path.resolve(path.dirname(filePath), imp.path.replace(/^["']|["']$/g, ''));
+                            return resolvedPath === path.resolve(err.filePath);
+                        });
+                        if (importLine) {
+                            errorLine = importLine.lineNumber;
+                        }
+                        else {
+                            // Fallback: place on first import line
+                            errorLine = config.imports[0]?.lineNumber ?? 0;
+                        }
+                    }
+                    const line = lines[errorLine] ?? '';
+                    const range = new vscode.Range(new vscode.Position(errorLine, 0), new vscode.Position(errorLine, line.length));
+                    pushNornDiagnostic(diagnostics, range, err.message, vscode.DiagnosticSeverity.Error, 'nornenv-import-error');
+                }
+            }
+        }
+        const sectionLineByName = new Map();
+        for (const section of sections) {
+            sectionLineByName.set(section.name, section);
+        }
+        for (const parentRef of parentReferences) {
+            if ((0, environmentParser_1.findExtendsTemplate)(parentRef.name, resolvedConfig)) {
+                continue;
+            }
+            const range = new vscode.Range(new vscode.Position(parentRef.section.lineNumber, parentRef.start), new vscode.Position(parentRef.section.lineNumber, parentRef.end));
+            const envParent = resolvedConfig.environments.find(env => env.name === parentRef.name);
+            if (envParent) {
+                pushNornDiagnostic(diagnostics, range, `Invalid extends parent '${parentRef.name}'. Environments cannot be inherited; extract shared values to [template:${parentRef.name}] and extend that template instead.`, vscode.DiagnosticSeverity.Error, 'extends-env-parent');
+                continue;
+            }
+            const closest = findClosestNornenvName(parentRef.name, [
+                ...resolvedConfig.templates.map(template => template.name)
+            ]);
+            pushNornDiagnostic(diagnostics, range, closest
+                ? `Unknown extends parent '${parentRef.name}'. Did you mean '${closest}'?`
+                : `Unknown extends parent '${parentRef.name}'. Define [template:${parentRef.name}] or remove it from extends.`, vscode.DiagnosticSeverity.Error, 'unknown-extends-parent');
+        }
+        for (const cycle of (0, environmentParser_1.detectExtendsCycles)(resolvedConfig)) {
+            const section = sectionLineByName.get(cycle.name);
+            if (!section) {
+                continue;
+            }
+            const line = lines[section.lineNumber] ?? '';
+            const range = new vscode.Range(new vscode.Position(section.lineNumber, 0), new vscode.Position(section.lineNumber, line.length));
+            pushNornDiagnostic(diagnostics, range, `Extends cycle detected: ${cycle.path.join(' -> ')}`, vscode.DiagnosticSeverity.Error, 'extends-cycle');
+        }
+        const allDeclaredNames = buildDeclaredNornenvNameSet(resolvedConfig);
+        for (const declaration of templateDeclarations) {
+            if (!declaration.sectionName) {
+                continue;
+            }
+            const found = (0, environmentParser_1.findExtendsNode)(declaration.sectionName, resolvedConfig);
+            if (!found || found.node.parents.length === 0) {
+                continue;
+            }
+            const inheritedNames = new Set([
+                ...Object.keys(resolvedConfig.common),
+                ...(0, environmentParser_1.collectAncestorVariableNames)(declaration.sectionName, resolvedConfig)
+            ]);
+            if (inheritedNames.has(declaration.name)) {
+                continue;
+            }
+            const closest = findClosestNornenvName(declaration.name, inheritedNames);
+            if (!closest) {
+                continue;
+            }
+            const nameStart = Math.max(0, lines[declaration.lineNumber].indexOf(declaration.name));
+            const range = new vscode.Range(new vscode.Position(declaration.lineNumber, nameStart), new vscode.Position(declaration.lineNumber, nameStart + declaration.name.length));
+            pushNornDiagnostic(diagnostics, range, `Variable '${declaration.name}' is not inherited by [${declaration.sectionKind}:${declaration.sectionName}]. Did you mean to override '${closest}'?`, vscode.DiagnosticSeverity.Warning, 'unknown-override-target');
+        }
+        const templateTokenRegex = /\{\{([^{}]+)\}\}/g;
+        for (const declaration of templateDeclarations) {
+            const allowedNames = buildAllowedNornenvReferenceNames(declaration, resolvedConfig);
+            templateTokenRegex.lastIndex = 0;
+            for (const match of declaration.value.matchAll(templateTokenRegex)) {
+                const rawReference = match[1];
+                const referenceName = parseNornenvTemplateReference(rawReference);
+                const start = declaration.valueStart + (match.index ?? 0);
+                const end = start + match[0].length;
+                const range = new vscode.Range(new vscode.Position(declaration.lineNumber, start), new vscode.Position(declaration.lineNumber, end));
+                if (!referenceName) {
+                    pushNornDiagnostic(diagnostics, range, `.nornenv template reference '${rawReference.trim()}' is not supported. Use {{name}} or {{$env.name}}.`, vscode.DiagnosticSeverity.Error, 'unsupported-nornenv-template-reference');
+                    continue;
+                }
+                if (!allowedNames.has(referenceName)) {
+                    const declaredSomewhere = allDeclaredNames.has(referenceName);
+                    pushNornDiagnostic(diagnostics, range, declaredSomewhere && declaration.sectionName
+                        ? `.nornenv reference '${referenceName}' is not in scope for [${declaration.sectionKind}:${declaration.sectionName}]. Values in a section can reference common variables and ancestor variables only.`
+                        : `.nornenv reference '${referenceName}' was not found in common variables, templates, or environments.`, vscode.DiagnosticSeverity.Error, 'unresolved-cross-section-ref');
+                }
+            }
+        }
+        this.diagnosticCollection.set(document.uri, diagnostics);
+    }
+    clearDiagnostics(document) {
+        this.diagnosticCollection.delete(document.uri);
+    }
+    dispose() {
+        this.diagnosticCollection.dispose();
+    }
+}
+exports.DiagnosticProvider = DiagnosticProvider;
+//# sourceMappingURL=diagnosticProvider.js.map