norn-cli 2.2.2 → 2.4.0

package/out/completionProvider.js

@@ -0,0 +1,3739 @@
+"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.HttpCompletionProvider = exports.McpSignatureHelpProvider = void 0;
+const vscode = __importStar(require("vscode"));
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const parser_1 = require("./parser");
+const sequenceRunner_1 = require("./sequenceRunner");
+const environmentProvider_1 = require("./environmentProvider");
+const nornapiParser_1 = require("./nornapiParser");
+const mcpToolIntellisenseCache_1 = require("./mcpToolIntellisenseCache");
+const mcpToolSchema_1 = require("./mcpToolSchema");
+const swaggerBodyIntellisenseCache_1 = require("./swaggerBodyIntellisenseCache");
+const apiResponseIntellisenseCache_1 = require("./apiResponseIntellisenseCache");
+const nornSqlParser_1 = require("./nornSqlParser");
+const sqlConfig_1 = require("./sqlConfig");
+const sqlBuiltInAdapters_1 = require("./sqlBuiltInAdapters");
+const mcpConfig_1 = require("./mcpConfig");
+const nornConfig_1 = require("./nornConfig");
+const sequenceDeclaration_1 = require("./sequenceDeclaration");
+const TRIGGER_SUGGEST_COMMAND = 'editor.action.triggerSuggest';
+const TRIGGER_PARAMETER_HINTS_COMMAND = 'editor.action.triggerParameterHints';
+class McpSignatureHelpProvider {
+    provideSignatureHelp(document, position, _token, _context) {
+        const linePrefix = document.lineAt(position).text.substring(0, position.character);
+        const match = linePrefix.match(/^\s*(?: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_.:-]*)\((.*)$/i);
+        if (!match) {
+            return undefined;
+        }
+        const argsPrefix = match[3];
+        if (argsPrefix.includes(')')) {
+            return undefined;
+        }
+        const resolvedAlias = this.resolveKnownMcpAlias(document, match[1]);
+        if (!resolvedAlias) {
+            return undefined;
+        }
+        const cachedTool = (0, mcpToolIntellisenseCache_1.getCachedMcpToolForAlias)(document.uri.fsPath, resolvedAlias, match[2]);
+        if (!cachedTool) {
+            return undefined;
+        }
+        const parameterNames = (0, mcpToolSchema_1.getMcpToolInputParameterNames)(cachedTool);
+        const propertyMap = (0, mcpToolSchema_1.getMcpToolInputPropertyMap)(cachedTool);
+        const required = new Set((0, mcpToolSchema_1.getMcpToolRequiredParameterNames)(cachedTool).map(name => name.toLowerCase()));
+        const signatureState = this.getSignatureState(argsPrefix, parameterNames);
+        const signatureHelp = new vscode.SignatureHelp();
+        const parameterLabels = parameterNames.map(name => this.getMcpParameterLabel(name, propertyMap[name], required.has(name.toLowerCase())));
+        const signatureLabel = parameterNames.length > 0
+            ? `${cachedTool.name}(${parameterLabels.join(', ')})`
+            : `${cachedTool.name}()`;
+        const signature = new vscode.SignatureInformation(signatureLabel, this.buildSignatureDocumentation(cachedTool, parameterNames, propertyMap, required, signatureState));
+        signature.parameters = parameterNames.map((name, index) => {
+            const docs = this.buildParameterDocumentation(propertyMap[name]);
+            return new vscode.ParameterInformation(parameterLabels[index], docs);
+        });
+        signatureHelp.signatures = [signature];
+        signatureHelp.activeSignature = 0;
+        signatureHelp.activeParameter = signatureState.activeParameterIndex;
+        return signatureHelp;
+    }
+    resolveKnownMcpAlias(document, alias) {
+        try {
+            const config = (0, mcpConfig_1.loadNornMcpProjectConfig)(document.uri.fsPath);
+            return Object.keys(config.config.servers).find(candidate => candidate.toLowerCase() === alias.toLowerCase());
+        }
+        catch {
+            return undefined;
+        }
+    }
+    getMcpParameterTypeSummary(schema) {
+        if (!schema || typeof schema !== 'object' || Array.isArray(schema)) {
+            return undefined;
+        }
+        const candidate = schema;
+        if (Array.isArray(candidate.enum) && candidate.enum.length > 0) {
+            return 'enum';
+        }
+        if (typeof candidate.type === 'string') {
+            if (candidate.type === 'array') {
+                const itemType = this.getMcpParameterTypeSummary(candidate.items);
+                return itemType ? `array<${itemType}>` : 'array';
+            }
+            return candidate.type;
+        }
+        if (Array.isArray(candidate.type)) {
+            const types = candidate.type.filter((entry) => typeof entry === 'string');
+            return types.length > 0 ? types.join(' | ') : undefined;
+        }
+        if (candidate.properties && typeof candidate.properties === 'object' && !Array.isArray(candidate.properties)) {
+            return 'object';
+        }
+        if (candidate.items) {
+            return 'array';
+        }
+        return undefined;
+    }
+    getMcpParameterDescription(schema) {
+        if (!schema || typeof schema !== 'object' || Array.isArray(schema)) {
+            return undefined;
+        }
+        const candidate = schema;
+        if (typeof candidate.description === 'string' && candidate.description.trim()) {
+            return candidate.description.trim();
+        }
+        if (typeof candidate.title === 'string' && candidate.title.trim()) {
+            return candidate.title.trim();
+        }
+        return undefined;
+    }
+    getMcpParameterLabel(name, schema, isRequired) {
+        const typeSummary = this.getMcpParameterTypeSummary(schema);
+        const optionalMarker = isRequired ? '' : '?';
+        if (!typeSummary) {
+            return `${name}${optionalMarker}`;
+        }
+        return `${name}${optionalMarker}: ${typeSummary}`;
+    }
+    buildParameterDocumentation(schema) {
+        const description = this.getMcpParameterDescription(schema);
+        if (!description) {
+            return undefined;
+        }
+        return new vscode.MarkdownString(description);
+    }
+    getSignatureState(argsPrefix, parameterNames) {
+        const usedParameterNames = new Set();
+        const parts = (0, sequenceRunner_1.splitNamedArgumentList)(argsPrefix);
+        const endsWithComma = /,\s*$/.test(argsPrefix);
+        const completedParts = endsWithComma ? parts : parts.slice(0, -1);
+        const currentPart = endsWithComma ? '' : (parts.at(-1) ?? '');
+        let positionalIndex = 0;
+        const findParameterIndexByName = (name) => {
+            return parameterNames.findIndex(param => param.toLowerCase() === name.toLowerCase());
+        };
+        const advanceToNextUnboundPositionalIndex = () => {
+            while (positionalIndex < parameterNames.length && usedParameterNames.has(parameterNames[positionalIndex].toLowerCase())) {
+                positionalIndex++;
+            }
+            return positionalIndex;
+        };
+        for (const part of completedParts) {
+            const match = part.trim().match(/^([a-zA-Z_][a-zA-Z0-9_]*)\s*:/);
+            if (match) {
+                const declaredIndex = findParameterIndexByName(match[1]);
+                if (declaredIndex >= 0) {
+                    usedParameterNames.add(parameterNames[declaredIndex].toLowerCase());
+                }
+                continue;
+            }
+            const nextPositionalIndex = advanceToNextUnboundPositionalIndex();
+            if (nextPositionalIndex < parameterNames.length) {
+                usedParameterNames.add(parameterNames[nextPositionalIndex].toLowerCase());
+                positionalIndex = nextPositionalIndex + 1;
+            }
+        }
+        if (parameterNames.length === 0) {
+            return { activeParameterIndex: 0 };
+        }
+        const currentTrimmed = currentPart.trim();
+        let activeParameterIndex = advanceToNextUnboundPositionalIndex();
+        const namedMatch = currentTrimmed.match(/^([a-zA-Z_][a-zA-Z0-9_]*)\s*:/);
+        if (namedMatch) {
+            const declaredIndex = findParameterIndexByName(namedMatch[1]);
+            if (declaredIndex >= 0) {
+                activeParameterIndex = declaredIndex;
+            }
+        }
+        else if (/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(currentTrimmed)) {
+            const prefix = currentTrimmed.toLowerCase();
+            const prefixedMatchIndex = parameterNames.findIndex(name => !usedParameterNames.has(name.toLowerCase()) && name.toLowerCase().startsWith(prefix));
+            if (prefixedMatchIndex >= 0) {
+                activeParameterIndex = prefixedMatchIndex;
+            }
+        }
+        if (activeParameterIndex >= parameterNames.length) {
+            activeParameterIndex = parameterNames.length - 1;
+        }
+        const nextParameterIndex = parameterNames.findIndex((name, index) => index > activeParameterIndex &&
+            !usedParameterNames.has(name.toLowerCase()));
+        return {
+            activeParameterIndex,
+            nextParameterIndex: nextParameterIndex >= 0 ? nextParameterIndex : undefined
+        };
+    }
+    buildSignatureDocumentation(tool, parameterNames, propertyMap, required, signatureState) {
+        const lines = [];
+        if (tool.description) {
+            lines.push(tool.description);
+        }
+        if (parameterNames.length === 0) {
+            return lines.length > 0 ? new vscode.MarkdownString(lines.join('\n')) : undefined;
+        }
+        if (signatureState.nextParameterIndex !== undefined) {
+            const nextName = parameterNames[signatureState.nextParameterIndex];
+            const nextLabel = this.getMcpParameterLabel(nextName, propertyMap[nextName], required.has(nextName.toLowerCase()));
+            if (lines.length > 0) {
+                lines.push('');
+            }
+            lines.push(`**Next:** \`${nextLabel}\``);
+        }
+        return lines.length > 0 ? new vscode.MarkdownString(lines.join('\n')) : undefined;
+    }
+}
+exports.McpSignatureHelpProvider = McpSignatureHelpProvider;
+class HttpCompletionProvider {
+    httpMethods = ['GET', 'POST', 'PUT', 'DELETE', 'PATCH', 'HEAD', 'OPTIONS'];
+    keywords = ['var', 'test', 'test sequence', 'sequence', 'end sequence', 'if', 'end if', 'wait', 'run bash', 'run powershell', 'run js', 'run readJson', 'run sql', 'run mcp', 'run', 'print', 'assert', 'import', 'return', 'retry', 'backoff'];
+    nornapiKeywords = ['headers', 'end headers', 'endpoints', 'end endpoints'];
+    commonHeaders = [
+        'Content-Type',
+        'Authorization',
+        'Accept',
+        'Cache-Control',
+        'User-Agent',
+        'Accept-Encoding',
+        'Accept-Language',
+        'Connection',
+        'Host',
+        'Origin',
+        'Referer',
+        'Cookie',
+        'X-Requested-With',
+        'X-API-Key',
+    ];
+    contentTypes = [
+        'application/json',
+        'application/xml',
+        'application/x-www-form-urlencoded',
+        'multipart/form-data',
+        'text/plain',
+        'text/html',
+    ];
+    provideCompletionItems(document, position) {
+        const fileName = path.basename(document.uri.fsPath);
+        const lineText = document.lineAt(position).text;
+        const linePrefix = lineText.substring(0, position.character);
+        const lineSuffix = lineText.substring(position.character);
+        const trimmedPrefix = linePrefix.trim().toUpperCase();
+        if (fileName === nornConfig_1.NORN_CONFIG_FILENAME) {
+            return this.getNornConfigCompletions(document, position, linePrefix);
+        }
+        // Handle .nornapi files separately
+        if (document.languageId === 'nornapi') {
+            return this.getNornapiCompletions(document, position, linePrefix, lineSuffix);
+        }
+        if (document.languageId === 'nornsql') {
+            return this.getNornsqlCompletions(document, position, linePrefix);
+        }
+        // Don't provide completions inside comments
+        // Comments start with # but not #import
+        if (this.isInsideComment(linePrefix)) {
+            return [];
+        }
+        // File-path IntelliSense for import/run script paths.
+        const filePathCompletions = this.getFilePathCompletions(document, position, linePrefix);
+        if (filePathCompletions !== null) {
+            return filePathCompletions;
+        }
+        // EARLY CHECK: If typing a header value for Content-Type (works for both URL and API endpoint requests)
+        if (linePrefix.toLowerCase().includes('content-type:')) {
+            return this.getContentTypeCompletions();
+        }
+        // Check if user is typing a sequence tag (@)
+        if (this.isTypingSequenceTag(linePrefix)) {
+            return this.getSequenceTagCompletions(document, linePrefix);
+        }
+        // Check if user is typing a response capture reference ($N. or $N.body.)
+        if (this.isTypingResponseCapture(linePrefix)) {
+            return this.getResponseCaptureCompletions(document, position, linePrefix);
+        }
+        // Check if user is typing a variable property reference ({{varname.)
+        if (this.isTypingVariableProperty(linePrefix)) {
+            return this.getVariablePropertyCompletions(document, position, linePrefix, lineSuffix);
+        }
+        // Check if user is typing a variable reference (after { or {{)
+        if (this.isTypingVariable(linePrefix)) {
+            return this.getVariableCompletions(document, position, linePrefix, lineSuffix);
+        }
+        // Check if user is typing in a bare variable context (inside parentheses, after print, etc.)
+        // This should be checked early - before run command or endpoint checks
+        if (this.isTypingBareVariableContext(linePrefix, document, position)) {
+            return this.getBareVariableCompletions(document, position, linePrefix);
+        }
+        if (this.isTypingRunMcpCommand(linePrefix)) {
+            return this.getMcpCompletions(document, linePrefix);
+        }
+        if (this.isTypingRunSqlCommand(linePrefix)) {
+            return this.getSqlOperationCompletions(document, linePrefix);
+        }
+        // Check if user is typing after "run " - suggest named requests
+        if (this.isTypingRunCommand(linePrefix)) {
+            return this.getNamedRequestCompletions(document, linePrefix);
+        }
+        // Check if user is typing after a URL in a var request - suggest retry/backoff
+        // e.g., "var result = GET "https://..." " or "var data = GET https://api.com "
+        if (this.isTypingAfterRequestUrl(linePrefix)) {
+            return this.getRetryBackoffCompletions(linePrefix);
+        }
+        // Check if user is typing after HTTP method + endpoint - suggest header groups and retry/backoff
+        // e.g., "GET GetUser("1") " or "GET GetAllUsers " or "var x = GET GetUser(1) "
+        if (this.isTypingAfterApiEndpoint(linePrefix, document)) {
+            // Only suggest header groups in this context.
+            // If no header groups are defined in imported .nornapi files, show nothing.
+            return this.getHeaderGroupCompletions(document, linePrefix);
+        }
+        // Check if user is typing after HTTP method - suggest endpoints (in addition to URLs)
+        // e.g., "GET " could suggest "GetUser" endpoint
+        if (this.isTypingAfterHttpMethod(linePrefix)) {
+            const endpointCompletions = this.getEndpointCompletions(document, linePrefix);
+            if (endpointCompletions.length > 0) {
+                return endpointCompletions;
+            }
+        }
+        // Check if user is typing after "var x = " - suggest run commands
+        if (this.isTypingVarAssignment(linePrefix)) {
+            return this.getRunCompletionsForVarAssignment(document, linePrefix);
+        }
+        // Check if user is typing a variable name for property assignment (e.g., "config" or "config.")
+        if (this.isTypingPropertyAssignment(linePrefix)) {
+            return this.getPropertyAssignmentCompletions(document, linePrefix);
+        }
+        // Swagger-based request body IntelliSense for endpoint POST/PUT/PATCH calls.
+        const requestBodyContext = this.getRequestBodyCompletionContext(document, position);
+        if (requestBodyContext) {
+            if (this.isTypingJsonBodyStart(linePrefix)) {
+                return this.getRequestBodyTemplateCompletions(requestBodyContext, position, lineText);
+            }
+            const inlineBodyCompletions = this.getInlineRequestBodyKeyCompletions(requestBodyContext, document, position, linePrefix);
+            if (inlineBodyCompletions.length > 0) {
+                return inlineBodyCompletions;
+            }
+        }
+        const isAfterApiRequest = this.isAfterApiRequest(document, position);
+        // If a JSON body is being started right below an API request, don't show IntelliSense.
+        // We don't know body shape, and header/group suggestions are noisy in this context.
+        if (isAfterApiRequest && this.isTypingJsonBodyStart(linePrefix)) {
+            return [];
+        }
+        // Check if we're after an API request (GET EndpointName, etc.)
+        // Provide header groups and inline headers
+        if (isAfterApiRequest) {
+            // If typing a header name (no colon yet), provide both header groups and inline headers
+            if (!linePrefix.includes(':')) {
+                const headerGroupCompletions = this.getStandaloneHeaderGroupCompletions(document, linePrefix);
+                const headerCompletions = this.getHeaderCompletions();
+                return [...headerGroupCompletions, ...headerCompletions];
+            }
+            // If line has a colon but not Content-Type (which is handled earlier), return empty
+            return [];
+        }
+        // Check if user might be typing a JSON variable name for property assignment
+        const jsonVarCompletions = this.getJsonVariableCompletions(document, linePrefix);
+        // If we have JSON variable completions, show those (for property assignment)
+        if (jsonVarCompletions.length > 0) {
+            return jsonVarCompletions;
+        }
+        // Show HTTP methods/keywords at line start (or while typing them),
+        // but not after a METHOD ... context where endpoint/header logic applies.
+        if ((position.character === 0 || linePrefix.trim() === '' || this.couldBeMethodOrKeyword(trimmedPrefix)) &&
+            !this.isTypingAfterHttpMethod(linePrefix)) {
+            const typedPrefix = linePrefix.trim().toLowerCase();
+            const methodItems = this.getMethodCompletions(typedPrefix);
+            const keywordItems = this.getKeywordCompletions();
+            if (!typedPrefix) {
+                return [...methodItems, ...keywordItems];
+            }
+            const filteredKeywords = keywordItems.filter(item => item.label.toString().toLowerCase().startsWith(typedPrefix));
+            return [...methodItems, ...filteredKeywords];
+        }
+        return [];
+    }
+    /**
+     * Check if the cursor is inside a comment.
+     * Comments start with # but not #import
+     * This handles both line comments (# at start of line) and inline comments (# after code)
+     */
+    isInsideComment(linePrefix) {
+        const trimmed = linePrefix.trimStart();
+        // Check if line starts with # but not #import
+        if (trimmed.startsWith('#') && !trimmed.toLowerCase().startsWith('#import')) {
+            return true;
+        }
+        // Check for inline comments: find # that's not inside quotes and not part of #import
+        // We need to scan through the line and find if cursor is after an unquoted #
+        let inSingleQuote = false;
+        let inDoubleQuote = false;
+        for (let i = 0; i < linePrefix.length; i++) {
+            const char = linePrefix[i];
+            const prevChar = i > 0 ? linePrefix[i - 1] : '';
+            // Skip escaped quotes
+            if (prevChar === '\\') {
+                continue;
+            }
+            if (char === '"' && !inSingleQuote) {
+                inDoubleQuote = !inDoubleQuote;
+            }
+            else if (char === "'" && !inDoubleQuote) {
+                inSingleQuote = !inSingleQuote;
+            }
+            else if (char === '#' && !inSingleQuote && !inDoubleQuote) {
+                // Found an unquoted #, cursor is in a comment
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+     * Check if cursor is inside a quoted string
+     */
+    isInsideQuotes(linePrefix) {
+        let inSingleQuote = false;
+        let inDoubleQuote = false;
+        for (let i = 0; i < linePrefix.length; i++) {
+            const char = linePrefix[i];
+            const prevChar = i > 0 ? linePrefix[i - 1] : '';
+            // Skip escaped quotes
+            if (prevChar === '\\') {
+                continue;
+            }
+            if (char === '"' && !inSingleQuote) {
+                inDoubleQuote = !inDoubleQuote;
+            }
+            else if (char === "'" && !inDoubleQuote) {
+                inSingleQuote = !inSingleQuote;
+            }
+        }
+        return inSingleQuote || inDoubleQuote;
+    }
+    /**
+     * Provide filesystem-backed path completions in import/run-script contexts.
+     * Returns null when not in a filepath context.
+     */
+    getFilePathCompletions(document, position, linePrefix) {
+        const importContext = this.getImportPathCompletionContext(linePrefix);
+        if (importContext) {
+            return this.getRelativePathCompletions(document, position, importContext);
+        }
+        const runScriptContext = this.getRunScriptPathCompletionContext(linePrefix);
+        if (runScriptContext) {
+            return this.getRelativePathCompletions(document, position, runScriptContext);
+        }
+        return null;
+    }
+    /**
+     * Detect import path typing context:
+     * import "./..."
+     * import '../...'
+     * import ./...
+     */
+    getImportPathCompletionContext(linePrefix) {
+        const doubleQuotedMatch = linePrefix.match(/^\s*import\s+"([^"]*)$/i);
+        const singleQuotedMatch = linePrefix.match(/^\s*import\s+'([^']*)$/i);
+        const unquotedMatch = linePrefix.match(/^\s*import\s+(\S*)$/i);
+        const typedPath = doubleQuotedMatch?.[1] ?? singleQuotedMatch?.[1] ?? unquotedMatch?.[1];
+        if (!typedPath || !typedPath.startsWith('.')) {
+            return null;
+        }
+        return {
+            typedPath,
+            preferredExtensions: ['.norn', '.nornapi', '.nornsql']
+        };
+    }
+    /**
+     * Detect run-script path typing context:
+     * run bash ./...
+     * run powershell "./..."
+     * run js ../...
+     * var result = run bash ./...
+     */
+    getRunScriptPathCompletionContext(linePrefix) {
+        const runPrefixMatch = linePrefix.match(/^\s*(?:var\s+[a-zA-Z_][a-zA-Z0-9_]*\s*=\s*)?run\s+(bash|powershell|js|readjson)\s+(.*)$/i);
+        if (!runPrefixMatch) {
+            return null;
+        }
+        const runMethod = runPrefixMatch[1].toLowerCase();
+        const pathText = runPrefixMatch[2];
+        let typedPath = null;
+        if (pathText.startsWith('"')) {
+            const quotedPathMatch = pathText.match(/^"([^"]*)$/);
+            if (quotedPathMatch) {
+                typedPath = quotedPathMatch[1];
+            }
+        }
+        else if (pathText.startsWith('\'')) {
+            const quotedPathMatch = pathText.match(/^'([^']*)$/);
+            if (quotedPathMatch) {
+                typedPath = quotedPathMatch[1];
+            }
+        }
+        else {
+            const unquotedPathMatch = pathText.match(/^(\S*)$/);
+            if (unquotedPathMatch) {
+                typedPath = unquotedPathMatch[1];
+            }
+        }
+        if (!typedPath || !typedPath.startsWith('.')) {
+            return null;
+        }
+        return {
+            typedPath,
+            preferredExtensions: this.getPreferredRunScriptExtensions(runMethod)
+        };
+    }
+    getPreferredRunScriptExtensions(runMethod) {
+        switch (runMethod) {
+            case 'bash':
+                return ['.sh'];
+            case 'powershell':
+                return ['.ps1'];
+            case 'js':
+                return ['.js', '.mjs', '.cjs'];
+            case 'readjson':
+                return ['.json'];
+            default:
+                return [];
+        }
+    }
+    getPathEntryCompletionKind(entryName, isDirectory) {
+        if (isDirectory) {
+            return vscode.CompletionItemKind.Folder;
+        }
+        // Completion lists cannot use Explorer's file-icon-theme mapping per extension.
+        // Use File for all files so entries consistently show a non-empty file icon.
+        return vscode.CompletionItemKind.File;
+    }
+    getPathEntryDetail(entryName, isDirectory) {
+        if (isDirectory) {
+            return 'Directory';
+        }
+        const extension = path.extname(entryName).toLowerCase();
+        if (extension === '.norn') {
+            return 'Norn file';
+        }
+        if (extension === '.nornapi') {
+            return 'Norn API file';
+        }
+        if (extension === '.nornenv') {
+            return 'Norn environment file';
+        }
+        return extension ? `File (${extension})` : 'File';
+    }
+    getRelativePathCompletions(document, position, context) {
+        if (document.uri.scheme !== 'file') {
+            return [];
+        }
+        const typedPath = context.typedPath.replace(/\\/g, '/');
+        let directoryPart = '';
+        let entryPrefix = typedPath;
+        if (typedPath === '.') {
+            directoryPart = './';
+            entryPrefix = '';
+        }
+        else if (typedPath === '..') {
+            directoryPart = '../';
+            entryPrefix = '';
+        }
+        else if (typedPath.endsWith('/')) {
+            directoryPart = typedPath;
+            entryPrefix = '';
+        }
+        else {
+            const lastSlash = typedPath.lastIndexOf('/');
+            if (lastSlash >= 0) {
+                directoryPart = typedPath.substring(0, lastSlash + 1);
+                entryPrefix = typedPath.substring(lastSlash + 1);
+            }
+        }
+        const documentDir = path.dirname(document.uri.fsPath);
+        const lookupRelativePath = directoryPart || '.';
+        const lookupAbsolutePath = path.resolve(documentDir, lookupRelativePath);
+        let entries;
+        try {
+            const stats = fs.statSync(lookupAbsolutePath);
+            if (!stats.isDirectory()) {
+                return [];
+            }
+            entries = fs.readdirSync(lookupAbsolutePath, { withFileTypes: true });
+        }
+        catch {
+            return [];
+        }
+        const preferredExtensions = new Set(context.preferredExtensions.map(ext => ext.toLowerCase()));
+        const lowerPrefix = entryPrefix.toLowerCase();
+        const replaceStart = Math.max(0, position.character - context.typedPath.length);
+        const replaceRange = new vscode.Range(position.line, replaceStart, position.line, position.character);
+        const items = [];
+        for (const entry of entries) {
+            const entryName = entry.name;
+            if (entryName === '.' || entryName === '..') {
+                continue;
+            }
+            // Keep hidden entries out of the default list unless the user explicitly types a hidden prefix.
+            const isNornenvFile = entryName.toLowerCase() === '.nornenv';
+            if (entryName.startsWith('.') && !entryPrefix.startsWith('.') && !isNornenvFile) {
+                continue;
+            }
+            if (lowerPrefix && !entryName.toLowerCase().startsWith(lowerPrefix)) {
+                continue;
+            }
+            const isDirectory = entry.isDirectory();
+            const extension = path.extname(entryName).toLowerCase();
+            const insertPath = `${directoryPart}${entryName}${isDirectory ? '/' : ''}`;
+            const label = isDirectory ? `${entryName}/` : entryName;
+            const itemKind = this.getPathEntryCompletionKind(entryName, isDirectory);
+            // Preferred file extensions first, then folders, then all other files.
+            const priority = !isDirectory && preferredExtensions.has(extension)
+                ? '0'
+                : isDirectory
+                    ? '1'
+                    : '2';
+            items.push(this.createCompletionItem(label, itemKind, {
+                insertText: insertPath,
+                filterText: insertPath,
+                range: replaceRange,
+                detail: this.getPathEntryDetail(entryName, isDirectory),
+                command: isDirectory ? this.createTriggerSuggestCommand() : undefined,
+                sortText: `${priority}_${entryName.toLowerCase()}`
+            }));
+        }
+        return items;
+    }
+    /**
+     * Detect the start of a JSON body line (e.g., "{" or "[") under an API request.
+     */
+    isTypingJsonBodyStart(linePrefix) {
+        const trimmed = linePrefix.trimStart();
+        return trimmed.startsWith('{') || trimmed.startsWith('[');
+    }
+    /**
+     * Check if user is in a context where bare variable names should be suggested.
+     * This includes:
+     * - Inside function/endpoint parameters: GetUser(|) or GetUser(a, |)
+     * - After print keyword: print |
+     * - After operators in expressions: print "text" + |
+     * - In assertion expressions: assert | == something
+     *
+     * NOT triggered when:
+     * - Inside quoted strings
+     * - Inside {{ }} (handled by getVariableCompletions)
+     */
+    isTypingBareVariableContext(linePrefix, document, position) {
+        // Don't suggest if inside quotes
+        if (this.isInsideQuotes(linePrefix)) {
+            return false;
+        }
+        if (this.isInsideMcpCallArguments(linePrefix)) {
+            return false;
+        }
+        const trimmed = linePrefix.trim();
+        // Check if inside parentheses (endpoint parameters)
+        // e.g., "GET GetUser(" or "GetUser(a, "
+        const openParens = (linePrefix.match(/\(/g) || []).length;
+        const closeParens = (linePrefix.match(/\)/g) || []).length;
+        if (openParens > closeParens) {
+            // We're inside parentheses
+            const lastOpenParen = linePrefix.lastIndexOf('(');
+            const afterParen = linePrefix.substring(lastOpenParen + 1);
+            // Check we're not inside a string within the parens
+            if (!this.isInsideQuotes(afterParen)) {
+                return true;
+            }
+        }
+        // Check if after print keyword (but not in quotes)
+        // e.g., "print " or "print text + "
+        if (/^\s*print\s/i.test(linePrefix)) {
+            // Get everything after "print "
+            const printMatch = linePrefix.match(/print\s+(.*)$/i);
+            if (printMatch) {
+                const afterPrint = printMatch[1];
+                if (!this.isInsideQuotes(afterPrint)) {
+                    return true;
+                }
+            }
+            // If just "print " with nothing after, still show variables
+            if (/print\s+$/i.test(linePrefix)) {
+                return true;
+            }
+        }
+        // Check if after assert keyword
+        if (/^\s*assert\s/i.test(linePrefix)) {
+            const assertMatch = linePrefix.match(/assert\s+(.*)$/i);
+            if (assertMatch) {
+                const afterAssert = assertMatch[1];
+                if (!this.isInsideQuotes(afterAssert)) {
+                    return true;
+                }
+            }
+            if (/assert\s+$/i.test(linePrefix)) {
+                return true;
+            }
+        }
+        // Check if after return keyword
+        if (/^\s*return\s/i.test(linePrefix)) {
+            const returnMatch = linePrefix.match(/return\s+(.*)$/i);
+            if (returnMatch) {
+                const afterReturn = returnMatch[1];
+                if (!this.isInsideQuotes(afterReturn)) {
+                    return true;
+                }
+            }
+            if (/return\s+$/i.test(linePrefix)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    isInsideMcpCallArguments(linePrefix) {
+        const match = linePrefix.match(/^\s*(?: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_.:-]*\((.*)$/i);
+        if (!match) {
+            return false;
+        }
+        return !match[1].includes(')');
+    }
+    getSequenceLocalVariableNames(document, position, fullText = document.getText()) {
+        const sequences = (0, sequenceRunner_1.extractSequences)(fullText);
+        const containingSequence = sequences.find(seq => position.line > seq.startLine && position.line < seq.endLine);
+        const localVars = new Set();
+        if (!containingSequence) {
+            return localVars;
+        }
+        if (containingSequence.parameters) {
+            for (const param of containingSequence.parameters) {
+                localVars.add(param.name);
+            }
+        }
+        const lines = containingSequence.content.split('\n');
+        for (const line of lines) {
+            const varMatch = line.trim().match(/^var\s+([a-zA-Z_][a-zA-Z0-9_]*)\s*=/);
+            if (varMatch) {
+                localVars.add(varMatch[1]);
+            }
+        }
+        return localVars;
+    }
+    getEnvironmentVariablesForCompletion(pathOrSourceFile) {
+        const activeEnv = (0, environmentProvider_1.getActiveEnvironment)(pathOrSourceFile);
+        if (activeEnv) {
+            return (0, environmentProvider_1.getEnvironmentVariables)(pathOrSourceFile);
+        }
+        const config = (0, environmentProvider_1.loadEnvironmentConfig)(pathOrSourceFile);
+        if (!config) {
+            return {};
+        }
+        const variables = { ...config.common };
+        for (const env of config.environments) {
+            for (const [name, value] of Object.entries(env.variables)) {
+                if (!(name in variables)) {
+                    variables[name] = value;
+                }
+            }
+        }
+        return variables;
+    }
+    /**
+     * Get completions for bare variable names in contexts like print, parameters, etc.
+     */
+    getBareVariableCompletions(document, position, linePrefix) {
+        const fullText = document.getText();
+        const fileVariables = (0, parser_1.extractVariables)(fullText);
+        const envVariables = this.getEnvironmentVariablesForCompletion(document.uri.fsPath);
+        const envSecretNames = (0, environmentProvider_1.getEnvironmentSecretNames)(document.uri.fsPath);
+        const localVars = this.getSequenceLocalVariableNames(document, position, fullText);
+        // Merge all variables
+        const allVariables = new Map();
+        // Add environment variables
+        for (const [name, value] of Object.entries(envVariables)) {
+            allVariables.set(name, { value, source: 'env' });
+        }
+        // Add file variables
+        for (const [name, value] of Object.entries(fileVariables)) {
+            allVariables.set(name, { value, source: 'file' });
+        }
+        // Add local variables (highest priority)
+        for (const name of localVars) {
+            allVariables.set(name, { value: '(local)', source: 'local' });
+        }
+        if (allVariables.size === 0) {
+            return [];
+        }
+        // Determine what the user is already typing
+        let partialName = '';
+        const partialMatch = linePrefix.match(/[a-zA-Z_][a-zA-Z0-9_]*$/);
+        if (partialMatch) {
+            partialName = partialMatch[0];
+        }
+        const items = [];
+        for (const [name, { value, source }] of allVariables) {
+            // Filter by partial name if user has started typing
+            if (partialName && !name.toLowerCase().startsWith(partialName.toLowerCase())) {
+                continue;
+            }
+            const kind = source === 'env'
+                ? vscode.CompletionItemKind.Constant
+                : source === 'local'
+                    ? vscode.CompletionItemKind.Variable
+                    : vscode.CompletionItemKind.Field;
+            // Show source in detail
+            const shouldRedact = source === 'env' && envSecretNames.has(name) && value !== '(local)';
+            const detail = shouldRedact ? '***SECRET***' : value !== '(local)' ? value : undefined;
+            const sourceDesc = source === 'env'
+                ? '**Source:** Environment'
+                : source === 'local'
+                    ? '**Source:** Local sequence variable'
+                    : '**Source:** File';
+            items.push(this.createCompletionItem(name, kind, {
+                insertText: name,
+                detail,
+                documentation: new vscode.MarkdownString(`**Variable:** \`${name}\`\n\n${sourceDesc}`),
+                // Sort: local first, then file, then env
+                sortText: source === 'local' ? `0_${name}` : source === 'file' ? `1_${name}` : `2_${name}`
+            }));
+        }
+        return items;
+    }
+    /**
+     * Check if the line looks like code (variable assignment, etc.) rather than headers
+     */
+    looksLikeCode(linePrefix) {
+        const trimmed = linePrefix.trim();
+        // Looks like code if it starts with a lowercase letter followed by more text
+        // Headers typically start with uppercase (Content-Type, Authorization, etc.)
+        return /^[a-z_][a-zA-Z0-9_]*/.test(trimmed);
+    }
+    // Check if user is typing inside {{ }} for variable reference
+    // Only trigger when there's content before the {
+    isTypingVariable(linePrefix) {
+        const trimmed = linePrefix.trim();
+        // JSON body/object start should not trigger variable completions.
+        // Body IntelliSense handles this context separately.
+        if (trimmed === '{' || trimmed === '[') {
+            return false;
+        }
+        // Must have something before the brace (not just starting with {)
+        // e.g., "GET {{" or "Authorization: Bearer {{"
+        // Check for {{ with content before it
+        const doubleOpenMatch = trimmed.match(/\S+.*\{\{([a-zA-Z_][a-zA-Z0-9_]*)?$/);
+        if (doubleOpenMatch) {
+            return true;
+        }
+        // Check for single { at the end with content before it
+        const singleOpenMatch = trimmed.match(/\S+.*\{$/);
+        if (singleOpenMatch) {
+            return true;
+        }
+        // Keep suggestions active while typing after a single "{". Selecting a
+        // variable completion will expand it to the full "{{name}}" syntax.
+        const singleOpenPartialMatch = trimmed.match(/\S+.*\{([a-zA-Z_][a-zA-Z0-9_]*)$/);
+        if (singleOpenPartialMatch) {
+            return true;
+        }
+        return false;
+    }
+    getVariableBodyCompletionContext(linePrefix) {
+        const match = linePrefix.match(/(?:^|[\s({=+\-*!,]|\{\{)([a-zA-Z_][a-zA-Z0-9_]*)\.body((?:\.[a-zA-Z_][a-zA-Z0-9_-]*|\[\d+\])*(?:\.)?)$/i);
+        if (!match || !match[2]) {
+            return undefined;
+        }
+        return {
+            varName: match[1],
+            bodySuffix: match[2] || ''
+        };
+    }
+    getVariableHeaderCompletionContext(linePrefix) {
+        const match = linePrefix.match(/(?:^|[\s({=+\-*!,]|\{\{)([a-zA-Z_][a-zA-Z0-9_]*)\.headers\.([a-zA-Z_][a-zA-Z0-9_-]*)?$/i);
+        if (!match) {
+            return undefined;
+        }
+        return {
+            varName: match[1],
+            partial: match[2] || ''
+        };
+    }
+    getVariableTopLevelCompletionContext(linePrefix) {
+        const match = linePrefix.match(/(?:^|[\s({=+\-*!,]|\{\{)([a-zA-Z_][a-zA-Z0-9_]*)\.([a-zA-Z_][a-zA-Z0-9_]*)?$/);
+        if (!match) {
+            return undefined;
+        }
+        return {
+            varName: match[1],
+            partial: match[2] || ''
+        };
+    }
+    /**
+     * Check if user is typing a property access on a variable: {{varname. OR varname. (for assertions)
+     * Also handles cached response-body paths like user.body.profile.
+     */
+    isTypingVariableProperty(linePrefix) {
+        return Boolean(this.getVariableBodyCompletionContext(linePrefix) ||
+            this.getVariableHeaderCompletionContext(linePrefix) ||
+            this.getVariableTopLevelCompletionContext(linePrefix));
+    }
+    /**
+     * Get completions for variable properties based on what the variable was assigned from.
+     * If variable came from a sequence with a return statement, show the return fields.
+     * If variable came from a request (var x = GET url), show response properties.
+     * Also handles nested properties like user.body. or user.headers.
+     */
+    getVariablePropertyCompletions(document, position, linePrefix, lineSuffix) {
+        const fullText = document.getText();
+        // For {{varName.}} style, check for closing braces
+        let closingBraces = '';
+        if (/\{\{/.test(linePrefix)) {
+            const closingBracesAhead = lineSuffix.match(/^\}+/);
+            const numClosingBraces = closingBracesAhead ? closingBracesAhead[0].length : 0;
+            const bracesToAdd = Math.max(0, 2 - numClosingBraces);
+            closingBraces = '}'.repeat(bracesToAdd);
+        }
+        const bodyContext = this.getVariableBodyCompletionContext(linePrefix);
+        if (bodyContext) {
+            const requestSource = this.findCapturedRequestVariable(document, position, bodyContext.varName) ??
+                this.findCapturedRunNamedRequestVariable(document, fullText, bodyContext.varName) ??
+                this.findCapturedRunSequenceResponseVariable(document, fullText, bodyContext.varName);
+            if (!requestSource) {
+                return [];
+            }
+            return this.getCachedApiBodyPropertyCompletions(document, requestSource.line, requestSource.request, bodyContext.bodySuffix, closingBraces, requestSource.sourceFile) ?? [];
+        }
+        const headerContext = this.getVariableHeaderCompletionContext(linePrefix);
+        if (headerContext) {
+            const requestSource = this.findCapturedRequestVariable(document, position, headerContext.varName);
+            const isRunNamedRequestResponse = this.isVariableAssignedFromRunNamedRequest(document, fullText, headerContext.varName);
+            const isRunSequenceResponse = Boolean(this.findCapturedRunSequenceResponseVariable(document, fullText, headerContext.varName));
+            if (requestSource || isRunNamedRequestResponse || isRunSequenceResponse) {
+                return this.getCommonHeaderCompletions(closingBraces);
+            }
+            return [];
+        }
+        // Extract the variable name from {{varname. or just varname.
+        const topLevelContext = this.getVariableTopLevelCompletionContext(linePrefix);
+        if (!topLevelContext) {
+            return [];
+        }
+        const varName = topLevelContext.varName;
+        // Check if this variable was assigned from a request (var x = GET url)
+        const varRequestSource = this.findCapturedRequestVariable(document, position, varName);
+        if (varRequestSource) {
+            // Variable is a captured response - suggest response properties
+            return this.getResponsePropertyCompletions(closingBraces, varName, topLevelContext.partial);
+        }
+        // Check if this variable was assigned from a named request (var x = run GetToken)
+        if (this.isVariableAssignedFromRunNamedRequest(document, fullText, varName)) {
+            return this.getResponsePropertyCompletions(closingBraces, varName, topLevelContext.partial);
+        }
+        if (this.findCapturedRunSequenceResponseVariable(document, fullText, varName)) {
+            return this.getResponsePropertyCompletions(closingBraces, varName, topLevelContext.partial);
+        }
+        const sequenceAssignment = this.findRunSequenceAssignment(document, fullText, varName);
+        if (!sequenceAssignment) {
+            return [];
+        }
+        const sequenceName = sequenceAssignment.sequence.name;
+        // Get the return fields from the sequence
+        const returnFields = (0, sequenceRunner_1.extractReturnVariables)(sequenceAssignment.sequence.content);
+        if (!returnFields || returnFields.length === 0) {
+            return [];
+        }
+        const lowerPartial = topLevelContext.partial.toLowerCase();
+        // Create completions for each return field
+        return returnFields
+            .map(field => ({
+            expression: field,
+            fieldName: field.includes('.') ? field.split('.').pop() : field
+        }))
+            .filter(field => !lowerPartial || field.fieldName.toLowerCase().startsWith(lowerPartial))
+            .map(field => {
+            return this.createCompletionItem(field.fieldName, vscode.CompletionItemKind.Property, {
+                insertText: field.fieldName + closingBraces,
+                detail: `from ${sequenceName}`,
+                documentation: new vscode.MarkdownString(`Return field from sequence \`${sequenceName}\`\n\n**Expression:** \`${field.expression}\``),
+                sortText: `0_${field.fieldName}`
+            });
+        });
+    }
+    /**
+     * Checks whether a variable assignment uses "var x = run Name" where Name resolves to a named request
+     * (and not to a sequence, since run resolves sequences first at runtime).
+     */
+    isVariableAssignedFromRunNamedRequest(document, fullText, varName) {
+        return Boolean(this.findRunNamedRequestAssignment(document, fullText, varName));
+    }
+    findRunNamedRequestAssignment(document, fullText, varName) {
+        const varRunMatch = fullText.match(new RegExp(`var\\s+${varName}\\s*=\\s*run\\s+([a-zA-Z_][a-zA-Z0-9_-]*)(?:\\s*\\([^)]*\\))?`, 'i'));
+        if (!varRunMatch) {
+            return undefined;
+        }
+        const targetName = varRunMatch[1].toLowerCase();
+        const localSequences = (0, sequenceRunner_1.extractSequences)(fullText);
+        if (localSequences.some(seq => seq.name.toLowerCase() === targetName)) {
+            return undefined;
+        }
+        const localNamedRequests = (0, parser_1.extractNamedRequests)(fullText);
+        const localNamedRequest = localNamedRequests.find(req => req.name.toLowerCase() === targetName);
+        if (localNamedRequest) {
+            return { request: localNamedRequest, sourcePath: document.uri.fsPath };
+        }
+        const importedDefinitions = this.getImportedRunDefinitions(document);
+        if (importedDefinitions.sequences.some(entry => entry.sequence.name.toLowerCase() === targetName)) {
+            return undefined;
+        }
+        return importedDefinitions.namedRequests.find(entry => entry.request.name.toLowerCase() === targetName);
+    }
+    getNamedRequestApiResponseSource(namedRequest) {
+        const parsedRequest = (0, apiResponseIntellisenseCache_1.parseApiResponseRequestText)(namedRequest.request.content);
+        if (!parsedRequest) {
+            return undefined;
+        }
+        return {
+            sourceFile: namedRequest.sourcePath,
+            line: namedRequest.request.startLine + 1 + parsedRequest.lineOffset,
+            request: parsedRequest.request
+        };
+    }
+    findCapturedRunNamedRequestVariable(document, fullText, varName) {
+        const namedRequest = this.findRunNamedRequestAssignment(document, fullText, varName);
+        return namedRequest ? this.getNamedRequestApiResponseSource(namedRequest) : undefined;
+    }
+    findRunSequenceAssignment(document, fullText, varName) {
+        const varRunMatch = fullText.match(new RegExp(`var\\s+${varName}\\s*=\\s*run\\s+([a-zA-Z_][a-zA-Z0-9_-]*)(?:\\s*\\([^)]*\\))?`, 'i'));
+        if (!varRunMatch) {
+            return undefined;
+        }
+        const targetName = varRunMatch[1].toLowerCase();
+        const localSequence = (0, sequenceRunner_1.extractSequences)(fullText).find(seq => seq.name.toLowerCase() === targetName);
+        if (localSequence) {
+            return { sequence: localSequence, sourcePath: document.uri.fsPath };
+        }
+        return this.getImportedRunDefinitions(document).sequences.find(entry => entry.sequence.name.toLowerCase() === targetName);
+    }
+    findCapturedRunSequenceResponseVariable(document, fullText, varName) {
+        const sequenceAssignment = this.findRunSequenceAssignment(document, fullText, varName);
+        if (!sequenceAssignment) {
+            return undefined;
+        }
+        const returnFields = (0, sequenceRunner_1.extractReturnVariables)(sequenceAssignment.sequence.content);
+        if (!returnFields || returnFields.length !== 1) {
+            return undefined;
+        }
+        const returnVariableName = returnFields[0].trim();
+        if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(returnVariableName)) {
+            return undefined;
+        }
+        return this.findCapturedRequestVariableInSequence(document, sequenceAssignment, returnVariableName);
+    }
+    findCapturedRequestVariableInSequence(document, sequenceAssignment, varName) {
+        const lowerVarName = varName.toLowerCase();
+        const lines = sequenceAssignment.sequence.content.split('\n');
+        const returnLine = lines.findIndex(line => /^\s*return\b/i.test(line));
+        const searchStartLine = returnLine >= 0 ? returnLine : lines.length - 1;
+        const contentStartLine = this.getSequenceContentStartLine(document, sequenceAssignment);
+        for (let lineIndex = searchStartLine; lineIndex >= 0; lineIndex--) {
+            const request = (0, apiResponseIntellisenseCache_1.parseApiResponseRequestLine)(lines[lineIndex]);
+            if (request?.variableName?.toLowerCase() === lowerVarName) {
+                return {
+                    sourceFile: sequenceAssignment.sourcePath,
+                    line: contentStartLine + lineIndex,
+                    request
+                };
+            }
+        }
+        return undefined;
+    }
+    getSequenceContentStartLine(document, sequenceAssignment) {
+        const sourceText = this.readSourceText(document, sequenceAssignment.sourcePath);
+        if (!sourceText) {
+            return sequenceAssignment.sequence.startLine + 1;
+        }
+        const declarationLine = (0, sequenceDeclaration_1.findSequenceDeclarationLine)(sourceText.split('\n'), sequenceAssignment.sequence.startLine, sequenceAssignment.sequence.endLine);
+        return declarationLine + 1;
+    }
+    readSourceText(document, sourcePath) {
+        if (path.resolve(sourcePath) === path.resolve(document.uri.fsPath)) {
+            return document.getText();
+        }
+        try {
+            return fs.readFileSync(sourcePath, 'utf8');
+        }
+        catch {
+            return undefined;
+        }
+    }
+    findCapturedRequestVariable(document, position, varName) {
+        const lowerVarName = varName.toLowerCase();
+        for (let line = Math.min(position.line, document.lineCount - 1); line >= 0; line--) {
+            const request = (0, apiResponseIntellisenseCache_1.parseApiResponseRequestLine)(document.lineAt(line).text);
+            if (request?.variableName?.toLowerCase() === lowerVarName) {
+                return { sourceFile: document.uri.fsPath, line, request };
+            }
+        }
+        for (let line = position.line + 1; line < document.lineCount; line++) {
+            const request = (0, apiResponseIntellisenseCache_1.parseApiResponseRequestLine)(document.lineAt(line).text);
+            if (request?.variableName?.toLowerCase() === lowerVarName) {
+                return { sourceFile: document.uri.fsPath, line, request };
+            }
+        }
+        return undefined;
+    }
+    getCachedApiBodyPropertyCompletions(document, sourceLine, request, bodySuffix, closingBraces, sourceFile = document.uri.fsPath) {
+        const bodyPath = (0, apiResponseIntellisenseCache_1.parseApiResponseBodyPathForCompletion)(bodySuffix);
+        if (!bodyPath) {
+            return undefined;
+        }
+        const cachedEntry = (0, apiResponseIntellisenseCache_1.getCachedApiResponseShapeForRequest)({
+            sourceFile,
+            sourceLine,
+            method: request.method,
+            target: request.target,
+            environment: (0, environmentProvider_1.getActiveEnvironment)(sourceFile)
+        });
+        if (!cachedEntry) {
+            return undefined;
+        }
+        const node = (0, apiResponseIntellisenseCache_1.getApiResponseShapeNodeAtPath)(cachedEntry.shape, bodyPath.pathSegments);
+        const properties = (0, apiResponseIntellisenseCache_1.getApiResponseShapeProperties)(node);
+        const lowerPartial = bodyPath.partial.toLowerCase();
+        return properties
+            .filter(property => !lowerPartial || property.name.toLowerCase().startsWith(lowerPartial))
+            .map(property => this.createCachedApiBodyPropertyCompletion(property.name, property.shape, closingBraces, cachedEntry.cachedAt));
+    }
+    createCachedApiBodyPropertyCompletion(name, shape, closingBraces, cachedAt) {
+        return this.createCompletionItem(name, vscode.CompletionItemKind.Property, {
+            insertText: name + closingBraces,
+            detail: (0, apiResponseIntellisenseCache_1.getApiResponseShapeTypeSummary)(shape),
+            documentation: new vscode.MarkdownString(`Cached from the last VS Code run.\n\nCached at: \`${cachedAt}\``),
+            sortText: `0_${name.toLowerCase()}`
+        });
+    }
+    /**
+     * Get completions for response properties (used for variables that captured an HTTP response).
+     * Suggests: body, status, statusText, headers, duration, cookies
+     */
+    getResponsePropertyCompletions(closingBraces, varName, partial = '') {
+        const items = [];
+        const lowerPartial = partial.toLowerCase();
+        const responseProperties = [
+            { name: 'body', detail: 'Response body (parsed JSON or string)', doc: 'The response body. Access nested properties with `.body.property`' },
+            { name: 'status', detail: 'HTTP status code (number)', doc: 'The HTTP status code, e.g., 200, 404, 500' },
+            { name: 'statusText', detail: 'HTTP status text', doc: 'The HTTP status text, e.g., "OK", "Not Found"' },
+            { name: 'headers', detail: 'Response headers', doc: 'Access headers with `.headers.Content-Type`' },
+            { name: 'duration', detail: 'Request duration (ms)', doc: 'Time taken for the request in milliseconds' },
+            { name: 'cookies', detail: 'Response cookies', doc: 'Cookies set by the response' },
+        ];
+        for (const prop of responseProperties) {
+            if (lowerPartial && !prop.name.toLowerCase().startsWith(lowerPartial)) {
+                continue;
+            }
+            items.push(this.createCompletionItem(prop.name, vscode.CompletionItemKind.Property, {
+                insertText: prop.name + closingBraces,
+                detail: prop.detail,
+                documentation: new vscode.MarkdownString(`**${prop.name}**\n\n${prop.doc}\n\n**Usage:** \`{{${varName}.${prop.name}}}\``),
+                sortText: `0_${prop.name}`
+            }));
+        }
+        return items;
+    }
+    /**
+     * Get completions for common HTTP header names (used for .headers. context)
+     */
+    getCommonHeaderCompletions(closingBraces) {
+        const commonHeaders = [
+            'Content-Type',
+            'Content-Length',
+            'Cache-Control',
+            'Set-Cookie',
+            'Authorization',
+            'Location',
+            'X-Request-Id',
+            'X-Correlation-Id',
+            'ETag',
+            'Last-Modified',
+            'Expires',
+            'Date',
+            'Server',
+        ];
+        return commonHeaders.map(header => this.createCompletionItem(header, vscode.CompletionItemKind.Property, {
+            insertText: header + closingBraces,
+            detail: 'HTTP header'
+        }));
+    }
+    /**
+     * Search imported files for a sequence by name.
+     * Returns the sequence if found, or undefined if not.
+     */
+    /**
+     * Collect named requests and sequences from imported .norn files (including nested imports).
+     */
+    getImportedRunDefinitions(document) {
+        const fullText = document.getText();
+        const imports = (0, parser_1.extractImports)(fullText);
+        const namedRequests = [];
+        const sequences = [];
+        if (imports.length === 0) {
+            return { namedRequests, sequences };
+        }
+        const documentDir = path.dirname(document.uri.fsPath);
+        const visitedPaths = new Set([document.uri.fsPath]);
+        const collectFromFile = (absolutePath) => {
+            if (visitedPaths.has(absolutePath)) {
+                return;
+            }
+            visitedPaths.add(absolutePath);
+            let importedContent;
+            try {
+                importedContent = fs.readFileSync(absolutePath, 'utf8');
+            }
+            catch {
+                return;
+            }
+            const fileNamedRequests = (0, parser_1.extractNamedRequests)(importedContent);
+            for (const request of fileNamedRequests) {
+                namedRequests.push({ request, sourcePath: absolutePath });
+            }
+            const fileSequences = (0, sequenceRunner_1.extractSequences)(importedContent);
+            for (const sequence of fileSequences) {
+                sequences.push({ sequence, sourcePath: absolutePath });
+            }
+            const nestedImports = (0, parser_1.extractImports)(importedContent);
+            const importDir = path.dirname(absolutePath);
+            for (const nestedImport of nestedImports) {
+                if (nestedImport.path.endsWith('.nornapi') || nestedImport.path.endsWith('.nornsql')) {
+                    continue;
+                }
+                collectFromFile(path.resolve(importDir, nestedImport.path));
+            }
+        };
+        for (const imp of imports) {
+            if (imp.path.endsWith('.nornapi') || imp.path.endsWith('.nornsql')) {
+                continue;
+            }
+            collectFromFile(path.resolve(documentDir, imp.path));
+        }
+        return { namedRequests, sequences };
+    }
+    getImportedSqlDefinitions(document) {
+        const imports = (0, parser_1.extractImports)(document.getText());
+        const operations = [];
+        const documentDir = path.dirname(document.uri.fsPath);
+        const seenPaths = new Set();
+        for (const imp of imports) {
+            if (!imp.path.endsWith('.nornsql')) {
+                continue;
+            }
+            const absolutePath = path.resolve(documentDir, imp.path);
+            if (seenPaths.has(absolutePath)) {
+                continue;
+            }
+            seenPaths.add(absolutePath);
+            try {
+                const content = fs.readFileSync(absolutePath, 'utf8');
+                const parsed = (0, nornSqlParser_1.parseNornSqlFile)(content, absolutePath);
+                for (const operation of parsed.operations) {
+                    operations.push({ operation, sourcePath: absolutePath });
+                }
+            }
+            catch {
+                // Ignore unreadable files in completion flow.
+            }
+        }
+        return { operations };
+    }
+    getNornsqlCompletions(document, position, linePrefix) {
+        const items = [];
+        const trimmed = linePrefix.trim().toLowerCase();
+        const line = document.lineAt(position).text;
+        const beforeCursor = line.substring(0, position.character);
+        const blockStarts = document.getText(new vscode.Range(new vscode.Position(0, 0), position));
+        const queryStarts = (blockStarts.match(/^\s*query\b/gm) || []).length;
+        const commandStarts = (blockStarts.match(/^\s*command\b/gm) || []).length;
+        const queryEnds = (blockStarts.match(/^\s*end\s+query\s*$/gm) || []).length;
+        const commandEnds = (blockStarts.match(/^\s*end\s+command\s*$/gm) || []).length;
+        const insideQueryBody = queryStarts > queryEnds;
+        const insideCommandBody = commandStarts > commandEnds;
+        if (insideQueryBody || insideCommandBody) {
+            return [];
+        }
+        const keywordCandidates = [
+            { label: 'connection', insertText: 'connection ', detail: 'Declare the connection alias for this file' },
+            { label: 'query', insertText: new vscode.SnippetString('query $1\n$0\nend query'), detail: 'Define a row-returning SQL operation' },
+            { label: 'command', insertText: new vscode.SnippetString('command $1\n$0\nend command'), detail: 'Define a write/non-row SQL operation' },
+            { label: 'end query', insertText: 'end query', detail: 'End a query block' },
+            { label: 'end command', insertText: 'end command', detail: 'End a command block' }
+        ];
+        for (const candidate of keywordCandidates) {
+            if (trimmed && !candidate.label.startsWith(trimmed)) {
+                continue;
+            }
+            items.push(this.createCompletionItem(candidate.label, vscode.CompletionItemKind.Keyword, {
+                insertText: candidate.insertText,
+                detail: candidate.detail
+            }));
+        }
+        // Parameter-name suggestions while typing query/command headers.
+        const headerMatch = beforeCursor.match(/^\s*(query|command)\s+[A-Za-z_][A-Za-z0-9_-]*\(([^)]*)$/i);
+        if (headerMatch) {
+            const existing = new Set(headerMatch[2]
+                .split(',')
+                .map(part => part.trim())
+                .filter(Boolean)
+                .map(name => name.toLowerCase()));
+            const variables = {
+                ...(0, environmentProvider_1.getEnvironmentVariables)(document.uri.fsPath),
+                ...(0, parser_1.extractVariables)(document.getText())
+            };
+            for (const name of Object.keys(variables)) {
+                if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(name) || existing.has(name.toLowerCase())) {
+                    continue;
+                }
+                items.push(this.createCompletionItem(name, vscode.CompletionItemKind.Variable, {
+                    insertText: name,
+                    detail: 'Parameter name'
+                }));
+            }
+        }
+        return items;
+    }
+    getNornConfigCompletions(document, position, linePrefix) {
+        const items = [];
+        const line = document.lineAt(position).text;
+        const beforeCursor = line.substring(0, position.character);
+        if (/"adapter"\s*:\s*"[^"]*$/i.test(beforeCursor)) {
+            for (const adapter of (0, sqlBuiltInAdapters_1.getBuiltInSqlAdapters)()) {
+                const optionalConnectionText = adapter.optionalConnectionKeys.length > 0
+                    ? `Optional connection values: \`${adapter.optionalConnectionKeys.join('`, `')}\`\n\n`
+                    : '';
+                items.push(this.createValueCompletion(adapter.id, `${adapter.label} built-in adapter`, `0_${adapter.id}`, new vscode.MarkdownString(`${adapter.description}\n\n` +
+                    `Connection setup: \`${adapter.connectionSetupSummary}\`\n\n` +
+                    optionalConnectionText +
+                    `Built-in adapters do not need custom entries in \`${nornConfig_1.NORN_CONFIG_FILENAME}\` \`sql.adapters\`.`)));
+            }
+            try {
+                const adapterConfig = (0, sqlConfig_1.loadNornSqlAdaptersConfig)(document.uri.fsPath).config;
+                for (const adapterId of Object.keys(adapterConfig.adapters).sort()) {
+                    items.push(this.createValueCompletion(adapterId, `Custom adapter from ${nornConfig_1.NORN_CONFIG_FILENAME}`, `1_${adapterId}`, new vscode.MarkdownString(`Resolved from \`${nornConfig_1.NORN_CONFIG_FILENAME}\` \`sql.adapters\`.`)));
+                }
+            }
+            catch {
+                // Ignore incomplete config files in completion flow.
+            }
+            return items;
+        }
+        if (/"profile"\s*:\s*"[^"]*$/i.test(beforeCursor)) {
+            const environmentVariables = (0, environmentProvider_1.getEnvironmentVariables)(document.uri.fsPath);
+            const profileNames = new Set();
+            for (const key of Object.keys(environmentVariables)) {
+                const separatorIndex = key.indexOf('_');
+                if (separatorIndex <= 0) {
+                    continue;
+                }
+                profileNames.add(key.slice(0, separatorIndex));
+            }
+            for (const profileName of Array.from(profileNames).sort()) {
+                items.push(this.createValueCompletion(profileName, 'Profile inferred from .nornenv keys'));
+            }
+            return items;
+        }
+        if (/"command"\s*:\s*\[[^\]]*$/i.test(linePrefix)) {
+            items.push(this.createCompletionItem('custom adapter command', vscode.CompletionItemKind.Snippet, {
+                insertText: new vscode.SnippetString('"node", "./tools/adapters/${1:my-adapter}.js"'),
+                range: this.getJsonQuotedTokenRange(line, position),
+                detail: 'Command array for a custom adapter',
+                documentation: new vscode.MarkdownString(`Custom adapters live in \`${nornConfig_1.NORN_CONFIG_FILENAME}\` under \`sql.adapters\`. Built-in adapters like \`postgres\`, \`sqlserver\`, and \`sqlserver-windows\` do not need entries there.`)
+            }));
+        }
+        const propertyContext = this.getJsonPropertyCompletionContext(line, position);
+        if (propertyContext) {
+            items.push(this.createJsonPropertyCompletion('version', 'version property', '"version": 1', 'Config version', propertyContext));
+            items.push(this.createJsonPropertyCompletion('sql', 'SQL section definition', '"sql": {\n  "connections": {\n    "${1:appDb}": {\n      "adapter": "${2:postgres}",\n      "profile": "${3:appDb}"\n    }\n  },\n  "adapters": {\n    "${4:custom-adapter}": {\n      "command": ["${5:node}", "${6:./tools/adapters/my-adapter.js}"]\n    }\n  }\n}', 'Define SQL connections and custom adapters', propertyContext));
+            items.push(this.createJsonPropertyCompletion('mcp', 'MCP section definition', '"mcp": {\n  "servers": {\n    "${1:localTools}": {\n      "transport": "stdio",\n      "command": ["${2:node}", "${3:./tools/mcp-server.js}"]\n    },\n    "${4:remoteTools}": {\n      "transport": "http",\n      "url": "${5:https://mcp.example.com/mcp}",\n      "headers": {\n        "Authorization": "Bearer {{$env.${6:mcpToken}}}"\n      },\n      "timeoutMs": ${7:5000}\n    }\n  }\n}', 'Define MCP server aliases', propertyContext));
+        }
+        return items;
+    }
+    getJsonPropertyCompletionContext(line, position) {
+        const beforeCursor = line.substring(0, position.character);
+        const match = beforeCursor.match(/"?[A-Za-z0-9_-]*$/);
+        const typedToken = match?.[0] ?? '';
+        const prefixBeforeToken = beforeCursor.substring(0, position.character - typedToken.length).trim();
+        if (prefixBeforeToken.length > 0 && prefixBeforeToken !== ',' && prefixBeforeToken !== '{') {
+            return undefined;
+        }
+        const rangeEnd = typedToken.startsWith('"') && line[position.character] === '"'
+            ? position.character + 1
+            : position.character;
+        return {
+            range: new vscode.Range(position.line, position.character - typedToken.length, position.line, rangeEnd),
+            typedToken
+        };
+    }
+    getJsonQuotedTokenRange(line, position) {
+        const beforeCursor = line.substring(0, position.character);
+        const match = beforeCursor.match(/"?[A-Za-z0-9_-]*$/);
+        const token = match?.[0] ?? '';
+        if (!token.startsWith('"')) {
+            return undefined;
+        }
+        const rangeEnd = line[position.character] === '"'
+            ? position.character + 1
+            : position.character;
+        return new vscode.Range(position.line, position.character - token.length, position.line, rangeEnd);
+    }
+    createValueCompletion(label, detail, sortText, documentation) {
+        return this.createCompletionItem(label, vscode.CompletionItemKind.Value, {
+            insertText: label,
+            detail,
+            sortText,
+            documentation
+        });
+    }
+    createJsonPropertyCompletion(propertyName, label, snippetText, detail, context) {
+        const isQuotedCompletion = context.typedToken.startsWith('"');
+        return this.createCompletionItem(label, vscode.CompletionItemKind.Snippet, {
+            insertText: new vscode.SnippetString(snippetText),
+            range: context.range,
+            filterText: isQuotedCompletion ? `"${propertyName}"` : propertyName,
+            sortText: `000_${propertyName}`,
+            detail
+        });
+    }
+    createCompletionItem(label, kind, options = {}) {
+        const item = new vscode.CompletionItem(label, kind);
+        if (options.insertText !== undefined) {
+            item.insertText = options.insertText;
+        }
+        if (options.detail !== undefined) {
+            item.detail = options.detail;
+        }
+        if (options.documentation !== undefined) {
+            item.documentation = options.documentation;
+        }
+        if (options.sortText !== undefined) {
+            item.sortText = options.sortText;
+        }
+        if (options.filterText !== undefined) {
+            item.filterText = options.filterText;
+        }
+        if (options.range !== undefined) {
+            item.range = options.range;
+        }
+        if (options.command !== undefined) {
+            item.command = options.command;
+        }
+        if (options.preselect !== undefined) {
+            item.preselect = options.preselect;
+        }
+        return item;
+    }
+    createTriggerSuggestCommand(title = 'Trigger Suggest') {
+        return {
+            command: TRIGGER_SUGGEST_COMMAND,
+            title
+        };
+    }
+    /**
+     * Provide completions for .nornapi files
+     */
+    createEndBlockCompletion(label, detail) {
+        return this.createCompletionItem(label, vscode.CompletionItemKind.Keyword, {
+            detail,
+            sortText: '0_end'
+        });
+    }
+    getNornapiBlockContext(textBeforeCurrentLine) {
+        let currentBlock;
+        for (const line of textBeforeCurrentLine.split(/\r?\n/)) {
+            const trimmed = line.trim().toLowerCase();
+            if (!trimmed || trimmed.startsWith('#')) {
+                continue;
+            }
+            if (/^end\s+headers\b/.test(trimmed)) {
+                if (currentBlock === 'headers') {
+                    currentBlock = undefined;
+                }
+                continue;
+            }
+            if (/^end\s+endpoints\b/.test(trimmed)) {
+                if (currentBlock === 'endpoints') {
+                    currentBlock = undefined;
+                }
+                continue;
+            }
+            if (/^headers\b/.test(trimmed)) {
+                currentBlock = 'headers';
+                continue;
+            }
+            if (/^endpoints\b/.test(trimmed)) {
+                currentBlock = 'endpoints';
+            }
+        }
+        return currentBlock;
+    }
+    getNornapiCompletions(document, position, linePrefix, lineSuffix) {
+        const trimmed = linePrefix.trim().toLowerCase();
+        // Check if typing a variable reference ({{)
+        if (this.isTypingVariable(linePrefix)) {
+            return this.getVariableCompletions(document, position, linePrefix, lineSuffix);
+        }
+        // Determine context based on where we are in the file
+        const textBeforeCurrentLine = document.getText(new vscode.Range(new vscode.Position(0, 0), new vscode.Position(position.line, 0)));
+        const nornapiBlockContext = this.getNornapiBlockContext(textBeforeCurrentLine);
+        const inHeadersBlock = nornapiBlockContext === 'headers';
+        const inEndpointsBlock = nornapiBlockContext === 'endpoints';
+        const items = [];
+        // Inside headers block - suggest common header names or header values
+        if (inHeadersBlock) {
+            // Check if typing a header value for Content-Type
+            if (linePrefix.toLowerCase().includes('content-type:')) {
+                return this.getContentTypeCompletions();
+            }
+            // Check if typing "end"
+            if ('end headers'.startsWith(trimmed) || trimmed === 'end' || trimmed === 'end ') {
+                items.push(this.createEndBlockCompletion('end headers', 'Close the headers block'));
+            }
+            // Suggest common headers
+            for (const header of this.commonHeaders) {
+                if (!trimmed || header.toLowerCase().startsWith(trimmed)) {
+                    items.push(this.createCompletionItem(header, vscode.CompletionItemKind.Field, {
+                        insertText: header + ': ',
+                        detail: 'HTTP header',
+                        // Trigger IntelliSense again after inserting the header (for Content-Type values, etc.)
+                        command: this.createTriggerSuggestCommand()
+                    }));
+                }
+            }
+            return items;
+        }
+        // Inside endpoints block - suggest HTTP methods and "end endpoints"
+        if (inEndpointsBlock) {
+            // Check if typing "end"
+            if ('end endpoints'.startsWith(trimmed) || trimmed === 'end' || trimmed === 'end ') {
+                items.push(this.createEndBlockCompletion('end endpoints', 'Close the endpoints block'));
+            }
+            // Suggest endpoint definition pattern
+            if (!trimmed || /^[a-z]/i.test(trimmed)) {
+                items.push(this.createCompletionItem('EndpointName: GET', vscode.CompletionItemKind.Snippet, {
+                    insertText: new vscode.SnippetString('${1:EndpointName}: ${2|GET,POST,PUT,DELETE,PATCH|} ${3:url}'),
+                    detail: 'Define an API endpoint',
+                    documentation: 'Create a new endpoint definition.\n\nExample: `GetUser: GET /users/{id}`'
+                }));
+            }
+            return items;
+        }
+        // At top level - suggest "headers" and "endpoints" keywords
+        if (!trimmed || 'headers'.startsWith(trimmed)) {
+            items.push(this.createCompletionItem('headers', vscode.CompletionItemKind.Keyword, {
+                insertText: new vscode.SnippetString('headers ${1:GroupName}\n$0\nend headers'),
+                detail: 'Define a header group',
+                documentation: 'Create a reusable group of headers.\n\nExample:\n```\nheaders Auth\nAuthorization: Bearer {{token}}\nend headers\n```'
+            }));
+        }
+        if (!trimmed || 'endpoints'.startsWith(trimmed)) {
+            items.push(this.createCompletionItem('endpoints', vscode.CompletionItemKind.Keyword, {
+                insertText: new vscode.SnippetString('endpoints\n${1:EndpointName}: ${2|GET,POST,PUT,DELETE,PATCH|} ${3:url}\nend endpoints'),
+                detail: 'Define API endpoints',
+                documentation: 'Create a block of endpoint definitions.\n\nExample:\n```\nendpoints\nGetUser: GET /users/{id}\nCreateUser: POST /users\nend endpoints\n```'
+            }));
+        }
+        if (!trimmed || 'swagger'.startsWith(trimmed)) {
+            items.push(this.createCompletionItem('swagger', vscode.CompletionItemKind.Keyword, {
+                insertText: new vscode.SnippetString('swagger "$0"'),
+                detail: 'Import from OpenAPI/Swagger spec',
+                documentation: new vscode.MarkdownString('Import endpoints from an OpenAPI/Swagger specification URL.\n\n' +
+                    '**Usage:**\n```norn\nswagger https://petstore.swagger.io/v2/swagger.json\n```\n\n' +
+                    'Click the ▶ button to parse the spec and generate endpoints.\n\n' +
+                    'Supports OpenAPI 2.0 (Swagger) and OpenAPI 3.x specifications.')
+            }));
+        }
+        return items;
+    }
+    /**
+     * Load API definitions (header groups and endpoints) from imported .nornapi files.
+     */
+    getApiDefinitionsFromImports(document) {
+        const apiMetadata = this.getApiImportMetadata(document);
+        return {
+            headerGroups: apiMetadata.headerGroups,
+            endpoints: apiMetadata.endpoints
+        };
+    }
+    /**
+     * Load imported .nornapi files with endpoint/header data and swagger URL metadata.
+     */
+    getApiImportMetadata(document) {
+        const fullText = document.getText();
+        const imports = (0, parser_1.extractImports)(fullText);
+        const headerGroups = [];
+        const endpoints = [];
+        const apiFiles = [];
+        if (imports.length === 0) {
+            return { headerGroups, endpoints, apiFiles };
+        }
+        const documentDir = path.dirname(document.uri.fsPath);
+        for (const imp of imports) {
+            // Only process .nornapi files
+            if (!imp.path.endsWith('.nornapi')) {
+                continue;
+            }
+            try {
+                const importPath = path.resolve(documentDir, imp.path);
+                const importedContent = fs.readFileSync(importPath, 'utf8');
+                const apiDef = (0, nornapiParser_1.parseNornApiFile)(importedContent);
+                headerGroups.push(...apiDef.headerGroups);
+                endpoints.push(...apiDef.endpoints);
+                apiFiles.push({
+                    sourcePath: importPath,
+                    headerGroups: apiDef.headerGroups,
+                    endpoints: apiDef.endpoints,
+                    swaggerUrls: this.extractSwaggerUrlsFromNornapi(importedContent)
+                });
+            }
+            catch {
+                // Ignore import errors
+            }
+        }
+        return { headerGroups, endpoints, apiFiles };
+    }
+    extractSwaggerUrlsFromNornapi(content) {
+        const urls = new Set();
+        const lines = content.split('\n');
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (!trimmed || trimmed.startsWith('#')) {
+                continue;
+            }
+            const quotedMatch = trimmed.match(/^swagger\s+["']([^"']+)["']\s*$/i);
+            if (quotedMatch) {
+                urls.add(quotedMatch[1]);
+                continue;
+            }
+            const unquotedMatch = trimmed.match(/^swagger\s+(https?:\/\/\S+)\s*$/i);
+            if (unquotedMatch) {
+                urls.add(unquotedMatch[1]);
+            }
+        }
+        return Array.from(urls);
+    }
+    getRequestBodyCompletionContext(document, position) {
+        const apiMetadata = this.getApiImportMetadata(document);
+        if (apiMetadata.endpoints.length === 0 || apiMetadata.apiFiles.length === 0) {
+            return undefined;
+        }
+        const endpointSchemaMap = this.getEndpointRequestBodySchemaMap(apiMetadata);
+        if (endpointSchemaMap.size === 0) {
+            return undefined;
+        }
+        const headerGroupNames = new Set(apiMetadata.headerGroups.map(group => group.name));
+        for (let lineNum = position.line; lineNum >= 0 && lineNum >= position.line - 80; lineNum--) {
+            const trimmed = document.lineAt(lineNum).text.trim();
+            if (!trimmed || trimmed.startsWith('#')) {
+                continue;
+            }
+            const requestMatch = trimmed.match(/^(?:var\s+[a-zA-Z_][a-zA-Z0-9_]*\s*=\s*)?(GET|POST|PUT|DELETE|PATCH|HEAD|OPTIONS)\s+([a-zA-Z_][a-zA-Z0-9_]*)(?:\([^)]*\))?(?:\s+.*)?$/i);
+            if (requestMatch) {
+                const method = requestMatch[1].toUpperCase();
+                const endpointName = requestMatch[2];
+                if (!this.isRequestBodyMethod(method)) {
+                    return undefined;
+                }
+                const mapped = endpointSchemaMap.get(endpointName);
+                if (!mapped) {
+                    return undefined;
+                }
+                if (mapped.endpoint.method.toUpperCase() !== method) {
+                    return undefined;
+                }
+                const bodyStartLine = this.findRequestBodyStartLine(document, lineNum, position.line, headerGroupNames);
+                if (bodyStartLine === undefined || position.line < bodyStartLine) {
+                    return undefined;
+                }
+                return {
+                    method,
+                    endpointName,
+                    endpoint: mapped.endpoint,
+                    schema: mapped.schema,
+                    bodyStartLine
+                };
+            }
+            if (lineNum !== position.line && this.isBoundaryCommandLine(trimmed)) {
+                return undefined;
+            }
+        }
+        return undefined;
+    }
+    getEndpointRequestBodySchemaMap(apiMetadata) {
+        const endpointSchemaMap = new Map();
+        for (const apiFile of apiMetadata.apiFiles) {
+            if (apiFile.swaggerUrls.length === 0 || apiFile.endpoints.length === 0) {
+                continue;
+            }
+            const cacheEntries = apiFile.swaggerUrls
+                .map(url => (0, swaggerBodyIntellisenseCache_1.getCachedRequestBodySchemasForUrl)(url))
+                .filter((entry) => !!entry);
+            if (cacheEntries.length === 0) {
+                continue;
+            }
+            for (const endpoint of apiFile.endpoints) {
+                if (!this.isRequestBodyMethod(endpoint.method) || endpointSchemaMap.has(endpoint.name)) {
+                    continue;
+                }
+                const method = endpoint.method.toUpperCase();
+                for (const cacheEntry of cacheEntries) {
+                    const normalizedPath = this.normalizeEndpointPathForSwagger(endpoint.path, cacheEntry.baseUrl);
+                    if (!normalizedPath) {
+                        continue;
+                    }
+                    const matchedSchema = cacheEntry.schemas.find(schema => schema.method.toUpperCase() === method &&
+                        schema.path === normalizedPath);
+                    if (!matchedSchema) {
+                        continue;
+                    }
+                    endpointSchemaMap.set(endpoint.name, {
+                        endpoint,
+                        schema: matchedSchema
+                    });
+                    break;
+                }
+            }
+        }
+        return endpointSchemaMap;
+    }
+    normalizeEndpointPathForSwagger(endpointPath, baseUrl) {
+        const rawPath = endpointPath.trim();
+        if (!rawPath) {
+            return undefined;
+        }
+        const getBasePath = () => {
+            if (!baseUrl) {
+                return '';
+            }
+            try {
+                const parsed = new URL(baseUrl);
+                return parsed.pathname.replace(/\/$/, '');
+            }
+            catch {
+                return '';
+            }
+        };
+        const basePath = getBasePath();
+        const normalizeAndStripBasePath = (candidatePath) => {
+            const withoutQuery = candidatePath.split(/[?#]/)[0];
+            let normalized = withoutQuery.startsWith('/') ? withoutQuery : `/${withoutQuery}`;
+            if (basePath) {
+                if (normalized === basePath) {
+                    return '/';
+                }
+                if (normalized.startsWith(`${basePath}/`)) {
+                    normalized = normalized.slice(basePath.length);
+                }
+            }
+            return normalized || '/';
+        };
+        // Handle variable-prefix paths: {{baseUrl}}/users, {{apiRoot}}/v2/users, etc.
+        const variablePrefixMatch = rawPath.match(/^\{\{[^}]+\}\}(.*)$/);
+        if (variablePrefixMatch) {
+            const suffix = variablePrefixMatch[1] || '';
+            return normalizeAndStripBasePath(suffix || '/');
+        }
+        // Most imported endpoints are generated as full URLs, so strip baseUrl first when possible.
+        if (baseUrl && rawPath.startsWith(baseUrl)) {
+            const stripped = rawPath.slice(baseUrl.length);
+            return normalizeAndStripBasePath(stripped || '/');
+        }
+        if (/^https?:\/\//i.test(rawPath)) {
+            try {
+                const endpointUrl = new URL(rawPath);
+                if (baseUrl) {
+                    try {
+                        const parsedBaseUrl = new URL(baseUrl, endpointUrl.origin);
+                        const basePath = parsedBaseUrl.pathname.replace(/\/$/, '');
+                        // Compare by host to tolerate scheme differences (http vs https).
+                        if (endpointUrl.hostname === parsedBaseUrl.hostname) {
+                            if (basePath && endpointUrl.pathname.startsWith(`${basePath}/`)) {
+                                return endpointUrl.pathname.slice(basePath.length);
+                            }
+                            if (basePath && endpointUrl.pathname === basePath) {
+                                return '/';
+                            }
+                        }
+                    }
+                    catch {
+                        // Ignore malformed base URL values (e.g., templated server URLs)
+                    }
+                }
+                return normalizeAndStripBasePath(endpointUrl.pathname || '/');
+            }
+            catch {
+                return undefined;
+            }
+        }
+        return normalizeAndStripBasePath(rawPath);
+    }
+    findRequestBodyStartLine(document, requestLine, currentLine, headerGroupNames) {
+        for (let lineNum = requestLine + 1; lineNum <= currentLine; lineNum++) {
+            const trimmed = document.lineAt(lineNum).text.trim();
+            if (!trimmed || trimmed.startsWith('#')) {
+                continue;
+            }
+            if (headerGroupNames.has(trimmed)) {
+                continue;
+            }
+            if (this.isInlineHeaderLine(trimmed)) {
+                continue;
+            }
+            return lineNum;
+        }
+        return undefined;
+    }
+    isInlineHeaderLine(trimmedLine) {
+        return /^[A-Za-z][A-Za-z0-9-]*:\s*.+$/.test(trimmedLine);
+    }
+    isBoundaryCommandLine(trimmedLine) {
+        return /^(###|\[|(?:test\s+)?sequence\b|end\s+sequence\b|end\s+if\b|endif\b|var\s+|run\s+|print\s+|assert\s+|if\s+|wait\s+|import\s+|return\s+|swagger\b|(GET|POST|PUT|DELETE|PATCH|HEAD|OPTIONS)\s+)/i.test(trimmedLine);
+    }
+    isRequestBodyMethod(method) {
+        return method === 'POST' || method === 'PUT' || method === 'PATCH';
+    }
+    getRequestBodyTemplateCompletions(context, position, lineText) {
+        const templateValue = this.buildTemplateValueFromSchema(context.schema.schema);
+        const rawTemplate = JSON.stringify(templateValue, null, 4);
+        if (!rawTemplate) {
+            return [];
+        }
+        const indentation = lineText.match(/^\s*/)[0];
+        const indentedTemplate = rawTemplate
+            .split('\n')
+            .map(line => indentation + line)
+            .join('\n');
+        const replaceRange = new vscode.Range(new vscode.Position(position.line, 0), new vscode.Position(position.line, lineText.length));
+        const triggerChar = lineText.trimStart().startsWith('[') ? '[' : '{';
+        return [this.createCompletionItem('Insert request body template', vscode.CompletionItemKind.Snippet, {
+                insertText: indentedTemplate,
+                range: replaceRange,
+                filterText: triggerChar,
+                preselect: true,
+                detail: `${context.method} ${context.endpointName}`,
+                documentation: new vscode.MarkdownString(`Insert a request body skeleton for \`${context.endpointName}\` from cached Swagger schema.\n\n` +
+                    'Template includes required fields only.'),
+                sortText: '0_request_body_template'
+            })];
+    }
+    buildTemplateValueFromSchema(schema) {
+        const normalizedSchema = this.normalizeSchemaForCompletions(schema);
+        const value = this.buildDefaultSchemaValue(normalizedSchema, true);
+        return value === undefined ? {} : value;
+    }
+    buildDefaultSchemaValue(schema, requiredOnly) {
+        const normalizedSchema = this.normalizeSchemaForCompletions(schema);
+        if (!normalizedSchema || typeof normalizedSchema !== 'object') {
+            return null;
+        }
+        if (normalizedSchema.default !== undefined) {
+            return normalizedSchema.default;
+        }
+        if (Array.isArray(normalizedSchema.enum) && normalizedSchema.enum.length > 0) {
+            return normalizedSchema.enum[0];
+        }
+        if (normalizedSchema.type === 'object' || normalizedSchema.properties) {
+            const properties = normalizedSchema.properties;
+            if (!properties || Object.keys(properties).length === 0) {
+                return {};
+            }
+            const required = Array.isArray(normalizedSchema.required)
+                ? normalizedSchema.required.filter((name) => typeof name === 'string')
+                : [];
+            const keys = requiredOnly
+                ? (required.length > 0 ? required : Object.keys(properties))
+                : Object.keys(properties);
+            const result = {};
+            for (const key of keys) {
+                result[key] = this.buildDefaultSchemaValue(properties[key], requiredOnly);
+            }
+            return result;
+        }
+        if (normalizedSchema.type === 'array' || normalizedSchema.items) {
+            return [];
+        }
+        switch (normalizedSchema.type) {
+            case 'number':
+            case 'integer':
+                return 0;
+            case 'boolean':
+                return false;
+            case 'string':
+                return '';
+            case 'null':
+                return null;
+            default:
+                return null;
+        }
+    }
+    getInlineRequestBodyKeyCompletions(context, document, position, linePrefix) {
+        if (!this.isTypingJsonObjectKey(linePrefix)) {
+            return [];
+        }
+        const bodyLinesBeforeCursor = [];
+        for (let lineNum = context.bodyStartLine; lineNum < position.line; lineNum++) {
+            bodyLinesBeforeCursor.push(document.lineAt(lineNum).text);
+        }
+        const jsonContext = this.parseJsonObjectContext(bodyLinesBeforeCursor);
+        const schemaNode = this.getSchemaNodeForPath(context.schema.schema, jsonContext.path);
+        const normalizedSchema = this.normalizeSchemaForCompletions(schemaNode);
+        const properties = normalizedSchema?.properties;
+        if (!properties || Object.keys(properties).length === 0) {
+            return [];
+        }
+        const required = new Set(Array.isArray(normalizedSchema.required)
+            ? normalizedSchema.required.filter((name) => typeof name === 'string')
+            : []);
+        const replaceTokenMatch = linePrefix.match(/"?[a-zA-Z0-9_-]*$/);
+        const replaceToken = replaceTokenMatch ? replaceTokenMatch[0] : '';
+        const partialMatch = linePrefix.match(/"?([a-zA-Z_][a-zA-Z0-9_-]*)?$/);
+        const partial = partialMatch?.[1]?.toLowerCase() || '';
+        const replaceStart = Math.max(0, position.character - replaceToken.length);
+        const replaceRange = new vscode.Range(new vscode.Position(position.line, replaceStart), position);
+        const items = [];
+        for (const [propertyName, propertySchema] of Object.entries(properties)) {
+            if (jsonContext.existingKeys.has(propertyName)) {
+                continue;
+            }
+            if (partial && !propertyName.toLowerCase().startsWith(partial)) {
+                continue;
+            }
+            const detail = required.has(propertyName)
+                ? `${this.getSchemaTypeDescription(propertySchema)} (required)`
+                : this.getSchemaTypeDescription(propertySchema);
+            items.push(this.createCompletionItem(propertyName, vscode.CompletionItemKind.Property, {
+                range: replaceRange,
+                insertText: `"${propertyName}": `,
+                detail,
+                documentation: new vscode.MarkdownString(`Schema property for \`${context.endpointName}\` request body.`),
+                sortText: required.has(propertyName)
+                    ? `0_${propertyName}`
+                    : `1_${propertyName}`
+            }));
+        }
+        return items;
+    }
+    isTypingJsonObjectKey(linePrefix) {
+        const trimmed = linePrefix.trim();
+        if (trimmed.startsWith('{') || trimmed.startsWith('[') || trimmed.startsWith('}') || trimmed.startsWith(']')) {
+            return false;
+        }
+        if (trimmed.includes(':') || trimmed.includes(',')) {
+            return false;
+        }
+        if (trimmed === '' || trimmed === '"') {
+            return true;
+        }
+        return /^"?[a-zA-Z_][a-zA-Z0-9_-]*$/.test(trimmed);
+    }
+    parseJsonObjectContext(lines) {
+        const pathStack = [];
+        const keysByPath = new Map();
+        const getPathKey = () => pathStack.join('.');
+        const ensureKeySet = (pathKey) => {
+            if (!keysByPath.has(pathKey)) {
+                keysByPath.set(pathKey, new Set());
+            }
+            return keysByPath.get(pathKey);
+        };
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (!trimmed || trimmed.startsWith('#')) {
+                continue;
+            }
+            const closingMatch = trimmed.match(/^[}\]]+/);
+            if (closingMatch) {
+                for (const _ of closingMatch[0]) {
+                    if (pathStack.length > 0) {
+                        pathStack.pop();
+                    }
+                }
+            }
+            const currentPath = getPathKey();
+            const addExistingKey = (key) => {
+                ensureKeySet(currentPath).add(key);
+            };
+            const objectStartMatch = trimmed.match(/^"([^"]+)"\s*:\s*\{\s*,?\s*$/);
+            if (objectStartMatch) {
+                addExistingKey(objectStartMatch[1]);
+                pathStack.push(objectStartMatch[1]);
+                continue;
+            }
+            const arrayStartMatch = trimmed.match(/^"([^"]+)"\s*:\s*\[\s*,?\s*$/);
+            if (arrayStartMatch) {
+                addExistingKey(arrayStartMatch[1]);
+                pathStack.push(arrayStartMatch[1]);
+                continue;
+            }
+            const propertyMatch = trimmed.match(/^"([^"]+)"\s*:/);
+            if (propertyMatch) {
+                addExistingKey(propertyMatch[1]);
+            }
+        }
+        const finalPath = getPathKey();
+        return {
+            path: [...pathStack],
+            existingKeys: new Set(keysByPath.get(finalPath) || [])
+        };
+    }
+    getSchemaNodeForPath(schema, pathSegments) {
+        let currentSchema = this.normalizeSchemaForCompletions(schema);
+        for (const segment of pathSegments) {
+            currentSchema = this.normalizeSchemaForCompletions(currentSchema);
+            if (!currentSchema || typeof currentSchema !== 'object') {
+                return undefined;
+            }
+            const properties = currentSchema.properties;
+            if (!properties || !(segment in properties)) {
+                return undefined;
+            }
+            const propertySchema = this.normalizeSchemaForCompletions(properties[segment]);
+            if (propertySchema?.type === 'array' && propertySchema.items) {
+                currentSchema = this.normalizeSchemaForCompletions(propertySchema.items);
+            }
+            else {
+                currentSchema = propertySchema;
+            }
+        }
+        return this.normalizeSchemaForCompletions(currentSchema);
+    }
+    normalizeSchemaForCompletions(schema) {
+        if (!schema || typeof schema !== 'object') {
+            return schema;
+        }
+        if (Array.isArray(schema.allOf) && schema.allOf.length > 0) {
+            const merged = { ...schema };
+            delete merged.allOf;
+            for (const part of schema.allOf) {
+                const normalizedPart = this.normalizeSchemaForCompletions(part);
+                if (!normalizedPart || typeof normalizedPart !== 'object') {
+                    continue;
+                }
+                if (!merged.type && normalizedPart.type) {
+                    merged.type = normalizedPart.type;
+                }
+                if (normalizedPart.properties && typeof normalizedPart.properties === 'object') {
+                    merged.properties = {
+                        ...(merged.properties || {}),
+                        ...normalizedPart.properties
+                    };
+                }
+                if (normalizedPart.items && !merged.items) {
+                    merged.items = normalizedPart.items;
+                }
+                if (Array.isArray(normalizedPart.required)) {
+                    const existing = Array.isArray(merged.required) ? merged.required : [];
+                    merged.required = Array.from(new Set([...existing, ...normalizedPart.required]));
+                }
+            }
+            return merged;
+        }
+        if (Array.isArray(schema.oneOf) && schema.oneOf.length > 0) {
+            return this.normalizeSchemaForCompletions(schema.oneOf[0]);
+        }
+        if (Array.isArray(schema.anyOf) && schema.anyOf.length > 0) {
+            return this.normalizeSchemaForCompletions(schema.anyOf[0]);
+        }
+        return schema;
+    }
+    getSchemaTypeDescription(schema) {
+        const normalizedSchema = this.normalizeSchemaForCompletions(schema);
+        if (!normalizedSchema || typeof normalizedSchema !== 'object') {
+            return 'value';
+        }
+        if (Array.isArray(normalizedSchema.enum) && normalizedSchema.enum.length > 0) {
+            const enumPreview = normalizedSchema.enum
+                .slice(0, 3)
+                .map((value) => JSON.stringify(value))
+                .join(', ');
+            return normalizedSchema.enum.length > 3
+                ? `enum (${enumPreview}, ...)`
+                : `enum (${enumPreview})`;
+        }
+        if (typeof normalizedSchema.type === 'string') {
+            return normalizedSchema.type;
+        }
+        if (normalizedSchema.properties) {
+            return 'object';
+        }
+        if (normalizedSchema.items) {
+            return 'array';
+        }
+        return 'value';
+    }
+    /**
+     * Check if user is typing after an HTTP method (e.g., "GET " or "POST " or "var x = GET ")
+     * Returns false if inside open parentheses (user is typing parameters)
+     */
+    isTypingAfterHttpMethod(linePrefix) {
+        // Don't match if we're inside open parentheses (typing parameters)
+        const openParens = (linePrefix.match(/\(/g) || []).length;
+        const closeParens = (linePrefix.match(/\)/g) || []).length;
+        if (openParens > closeParens) {
+            return false;
+        }
+        // Match "METHOD " or "METHOD partial" (preserve trailing spaces)
+        let match = linePrefix.match(/^\s*(GET|POST|PUT|DELETE|PATCH|HEAD|OPTIONS)\s+.*$/i);
+        if (match) {
+            return true;
+        }
+        // Also match "var x = METHOD " pattern
+        match = linePrefix.match(/^\s*var\s+[a-zA-Z_][a-zA-Z0-9_]*\s*=\s*(GET|POST|PUT|DELETE|PATCH|HEAD|OPTIONS)\s+.*$/i);
+        return !!match;
+    }
+    /**
+     * Check if user is typing after an API endpoint (for header group suggestions)
+     * e.g., "GET GetUser("1") " or "GET GetAllUsers " or "var x = GET GetUser(1) "
+     */
+    isTypingAfterApiEndpoint(linePrefix, document) {
+        // Match: METHOD EndpointName or METHOD EndpointName(params) followed by space
+        // Also match: var x = METHOD EndpointName(params) followed by space
+        let match = linePrefix.match(/^\s*(GET|POST|PUT|DELETE|PATCH|HEAD|OPTIONS)\s+([a-zA-Z_][a-zA-Z0-9_]*)(?:\([^)]*\))?\s+.*$/i);
+        if (!match) {
+            // Try var x = METHOD EndpointName(params) pattern
+            match = linePrefix.match(/^\s*var\s+[a-zA-Z_][a-zA-Z0-9_]*\s*=\s*(GET|POST|PUT|DELETE|PATCH|HEAD|OPTIONS)\s+([a-zA-Z_][a-zA-Z0-9_]*)(?:\([^)]*\))?\s+.*$/i);
+        }
+        if (!match) {
+            return false;
+        }
+        const potentialEndpointName = match[2];
+        // Check if this is actually an endpoint from .nornapi imports
+        const apiDefs = this.getApiDefinitionsFromImports(document);
+        return apiDefs.endpoints.some(ep => ep.name === potentialEndpointName);
+    }
+    /**
+     * Check if user is typing after a URL in a var request line
+     * e.g., "var result = GET "https://..." " or "var data = GET https://api.com "
+     */
+    isTypingAfterRequestUrl(linePrefix) {
+        const trimmed = linePrefix.trim();
+        // Match: var name = METHOD "url" (quoted URL with everything after closing quote)
+        // or: var name = METHOD url (unquoted URL ending in space)
+        const quotedMatch = trimmed.match(/^var\s+[a-zA-Z_][a-zA-Z0-9_]*\s*=\s*(GET|POST|PUT|DELETE|PATCH|HEAD|OPTIONS)\s+"[^"]+"\s+/i);
+        if (quotedMatch) {
+            return true;
+        }
+        // Also match unquoted URLs: var x = GET https://url space
+        const unquotedMatch = trimmed.match(/^var\s+[a-zA-Z_][a-zA-Z0-9_]*\s*=\s*(GET|POST|PUT|DELETE|PATCH|HEAD|OPTIONS)\s+https?:\/\/\S+\s+/i);
+        if (unquotedMatch) {
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Get retry/backoff completions after a request URL
+     */
+    getRetryBackoffCompletions(linePrefix) {
+        const items = [];
+        const trimmed = linePrefix.trim().toLowerCase();
+        // If retry is not already on the line, suggest it
+        if (!trimmed.includes('retry')) {
+            items.push(this.createCompletionItem('retry', vscode.CompletionItemKind.Keyword, {
+                detail: 'Retry failed requests',
+                documentation: 'retry N - Retry the request N times on failure (5xx, 429, network errors)',
+                insertText: 'retry '
+            }));
+        }
+        // If backoff is not already on the line, suggest it
+        if (!trimmed.includes('backoff')) {
+            items.push(this.createCompletionItem('backoff', vscode.CompletionItemKind.Keyword, {
+                detail: 'Backoff duration between retries',
+                documentation: 'backoff N ms - Wait N milliseconds between retries (linear: N * attempt)',
+                insertText: 'backoff '
+            }));
+        }
+        return items;
+    }
+    /**
+     * Get endpoint completions after HTTP method
+     */
+    getEndpointCompletions(document, linePrefix) {
+        const apiDefs = this.getApiDefinitionsFromImports(document);
+        if (apiDefs.endpoints.length === 0) {
+            return [];
+        }
+        // Extract what's typed after the method
+        // Try "METHOD partial" first, then "var x = METHOD partial"
+        let match = linePrefix.match(/^\s*(GET|POST|PUT|DELETE|PATCH|HEAD|OPTIONS)\s+(.*)$/i);
+        if (!match) {
+            match = linePrefix.match(/^\s*var\s+[a-zA-Z_][a-zA-Z0-9_]*\s*=\s*(GET|POST|PUT|DELETE|PATCH|HEAD|OPTIONS)\s+(.*)$/i);
+        }
+        if (!match) {
+            return [];
+        }
+        const methodFromLine = match[1].toUpperCase();
+        const partial = (match[2] || '').trim();
+        const items = [];
+        for (const endpoint of apiDefs.endpoints) {
+            // Only show endpoints matching the currently typed method
+            if (endpoint.method !== methodFromLine) {
+                continue;
+            }
+            // Filter by typed endpoint prefix (if any)
+            if (partial && !endpoint.name.toLowerCase().startsWith(partial.toLowerCase())) {
+                continue;
+            }
+            // Show endpoint details
+            const endpointSignature = `${endpoint.method} ${endpoint.path}`;
+            items.push(this.createCompletionItem(endpoint.name, vscode.CompletionItemKind.Function, {
+                // Just insert the endpoint name - let user add () and arguments manually
+                insertText: endpoint.name,
+                detail: endpointSignature,
+                documentation: new vscode.MarkdownString(`**${endpoint.name}**\n\n\`${endpointSignature}\`\n\n` +
+                    (endpoint.parameters.length > 0
+                        ? `Parameters: ${endpoint.parameters.map(p => `\`{${p}}\``).join(', ')}`
+                        : 'No parameters')),
+                sortText: `0_${endpoint.name}`
+            }));
+        }
+        return items;
+    }
+    /**
+     * Get header group completions after an API endpoint
+     */
+    createHeaderGroupCompletion(hg, insertText) {
+        const headerList = Object.entries(hg.headers)
+            .map(([name, value]) => `  ${name}: ${value}`)
+            .join('\n');
+        return this.createCompletionItem(hg.name, vscode.CompletionItemKind.Module, {
+            insertText,
+            detail: `Header group (${Object.keys(hg.headers).length} headers)`,
+            documentation: new vscode.MarkdownString(`**${hg.name}**\n\nHeaders:\n\`\`\`\n${headerList}\n\`\`\``),
+            sortText: `0_${hg.name}`
+        });
+    }
+    getHeaderGroupCompletions(document, linePrefix) {
+        const apiDefs = this.getApiDefinitionsFromImports(document);
+        if (apiDefs.headerGroups.length === 0) {
+            return [];
+        }
+        const trimmed = linePrefix.trim();
+        // Extract what's already typed after the endpoint
+        // Pattern: METHOD EndpointName(params) [HeaderGroups...] partial
+        // Also: var x = METHOD EndpointName(params) [HeaderGroups...] partial
+        let match = trimmed.match(/^(GET|POST|PUT|DELETE|PATCH|HEAD|OPTIONS)\s+([a-zA-Z_][a-zA-Z0-9_]*)(?:\([^)]*\))?\s+(.*)$/i);
+        if (!match) {
+            // Try var x = METHOD EndpointName(params) pattern
+            match = trimmed.match(/^var\s+[a-zA-Z_][a-zA-Z0-9_]*\s*=\s*(GET|POST|PUT|DELETE|PATCH|HEAD|OPTIONS)\s+([a-zA-Z_][a-zA-Z0-9_]*)(?:\([^)]*\))?\s+(.*)$/i);
+        }
+        let alreadyUsed = [];
+        let partial = '';
+        if (match) {
+            const afterEndpoint = match[3] || '';
+            const tokens = afterEndpoint.split(/\s+/).filter(t => t); // Filter out empty tokens
+            // The last token might be a partial word being typed
+            if (tokens.length > 0) {
+                const lastToken = tokens[tokens.length - 1];
+                // Check if last token is a complete header group name
+                if (apiDefs.headerGroups.some(hg => hg.name === lastToken)) {
+                    // It's complete, so partial is empty
+                    alreadyUsed = tokens;
+                }
+                else {
+                    // Last token is a partial
+                    partial = lastToken;
+                    alreadyUsed = tokens.slice(0, -1);
+                }
+            }
+            // If no tokens, partial stays empty and we show all header groups
+        }
+        const items = [];
+        for (const hg of apiDefs.headerGroups) {
+            // Skip already used header groups
+            if (alreadyUsed.includes(hg.name)) {
+                continue;
+            }
+            // Filter by partial
+            if (partial && !hg.name.toLowerCase().startsWith(partial.toLowerCase())) {
+                continue;
+            }
+            items.push(this.createHeaderGroupCompletion(hg, hg.name + ' '));
+        }
+        return items;
+    }
+    /**
+     * Check if we're on a line after an HTTP request.
+     * Supports:
+     * - METHOD EndpointName / METHOD URL
+     * - var x = METHOD EndpointName / URL
+     * Allows inline headers and header groups on following lines.
+     */
+    isAfterApiRequest(document, position) {
+        const apiDefs = this.getApiDefinitionsFromImports(document);
+        // Look at previous lines to see if we're after a request block start.
+        for (let lineNum = position.line - 1; lineNum >= 0 && lineNum >= position.line - 10; lineNum--) {
+            const prevLine = document.lineAt(lineNum).text.trim();
+            // Skip empty lines
+            if (!prevLine) {
+                // Empty line means we're past the request block
+                return false;
+            }
+            // Skip comment lines
+            if (prevLine.startsWith('#')) {
+                continue;
+            }
+            // Skip header group names on their own line
+            if (apiDefs.headerGroups.some(hg => hg.name === prevLine)) {
+                continue;
+            }
+            // Skip inline headers (lines with HeaderName: value pattern)
+            if (/^[A-Za-z][A-Za-z0-9-]*:\s*.+$/.test(prevLine)) {
+                continue;
+            }
+            // Request start: METHOD ...
+            if (/^(GET|POST|PUT|DELETE|PATCH|HEAD|OPTIONS)\s+.+$/i.test(prevLine)) {
+                return true;
+            }
+            // Request start: var x = METHOD ...
+            if (/^var\s+[a-zA-Z_][a-zA-Z0-9_]*\s*=\s*(GET|POST|PUT|DELETE|PATCH|HEAD|OPTIONS)\s+.+$/i.test(prevLine)) {
+                return true;
+            }
+            // If we hit another kind of line that's not recognized, stop
+            break;
+        }
+        return false;
+    }
+    /**
+     * Check if user might be typing a header group name on its own line
+     * This happens after an API request when header groups are on separate lines:
+     *   GET GetAllUsers
+     *   Json
+     *   Auth
+     */
+    isTypingStandaloneHeaderGroup(linePrefix, document, position) {
+        const trimmed = linePrefix.trim();
+        // Must be a simple identifier (no spaces, colons, or special chars except what's being typed)
+        if (trimmed.includes(':') || trimmed.includes(' ') || trimmed.includes('/')) {
+            return false;
+        }
+        // Check if there are any .nornapi imports with header groups
+        const apiDefs = this.getApiDefinitionsFromImports(document);
+        if (apiDefs.headerGroups.length === 0) {
+            return false;
+        }
+        // Check if any header group name starts with what's typed
+        if (trimmed && !apiDefs.headerGroups.some(hg => hg.name.toLowerCase().startsWith(trimmed.toLowerCase()))) {
+            return false;
+        }
+        // Look at previous lines to see if we're after an API request
+        for (let lineNum = position.line - 1; lineNum >= 0 && lineNum >= position.line - 10; lineNum--) {
+            const prevLine = document.lineAt(lineNum).text.trim();
+            // Skip empty lines and header group names
+            if (!prevLine || apiDefs.headerGroups.some(hg => hg.name === prevLine)) {
+                continue;
+            }
+            // Check if this line is an API request (METHOD EndpointName)
+            const match = prevLine.match(/^(GET|POST|PUT|DELETE|PATCH|HEAD|OPTIONS)\s+([a-zA-Z_][a-zA-Z0-9_]*)(?:\([^)]*\))?/i);
+            if (match) {
+                const endpointName = match[2];
+                if (apiDefs.endpoints.some(ep => ep.name === endpointName)) {
+                    return true;
+                }
+            }
+            // If we hit another kind of line (not empty, not header group, not API request), stop
+            break;
+        }
+        return false;
+    }
+    /**
+     * Get header group completions for a standalone line (after an API request)
+     */
+    getStandaloneHeaderGroupCompletions(document, linePrefix) {
+        const apiDefs = this.getApiDefinitionsFromImports(document);
+        const trimmed = linePrefix.trim();
+        const items = [];
+        for (const hg of apiDefs.headerGroups) {
+            if (trimmed && !hg.name.toLowerCase().startsWith(trimmed.toLowerCase())) {
+                continue;
+            }
+            items.push(this.createHeaderGroupCompletion(hg, hg.name));
+        }
+        return items;
+    }
+    getVariableCompletions(document, position, linePrefix, lineSuffix) {
+        const fullText = document.getText();
+        const fileVariables = (0, parser_1.extractVariables)(fullText);
+        const envVariables = this.getEnvironmentVariablesForCompletion(document.uri.fsPath);
+        const envSecretNames = (0, environmentProvider_1.getEnvironmentSecretNames)(document.uri.fsPath);
+        const activeEnv = (0, environmentProvider_1.getActiveEnvironment)(document.uri.fsPath);
+        const localVars = this.getSequenceLocalVariableNames(document, position, fullText);
+        const replacementRange = (length) => new vscode.Range(new vscode.Position(position.line, Math.max(0, position.character - length)), position);
+        const allVariables = new Map();
+        // Merge: env variables first, then file variables, then local variables.
+        for (const [name, value] of Object.entries(envVariables)) {
+            allVariables.set(name, { value, source: 'env' });
+        }
+        for (const [name, value] of Object.entries(fileVariables)) {
+            allVariables.set(name, { value, source: 'file' });
+        }
+        for (const name of localVars) {
+            allVariables.set(name, { value: '(local)', source: 'local' });
+        }
+        const endsWithDoubleBrace = linePrefix.endsWith('{{');
+        const endsWithSingleBrace = linePrefix.endsWith('{') && !endsWithDoubleBrace;
+        const partialVarMatch = linePrefix.match(/\{\{([a-zA-Z_][a-zA-Z0-9_]*)$/);
+        const partialSingleVarMatch = !partialVarMatch
+            ? linePrefix.match(/\{([a-zA-Z_][a-zA-Z0-9_]*)$/)
+            : null;
+        const partialVarName = partialVarMatch
+            ? partialVarMatch[1]
+            : partialSingleVarMatch
+                ? partialSingleVarMatch[1]
+                : '';
+        const isSingleBracePartial = Boolean(partialSingleVarMatch);
+        const partialScopeMatch = linePrefix.match(/\{\{(\$[a-zA-Z_]*)$/);
+        const partialSingleScopeMatch = !partialScopeMatch
+            ? linePrefix.match(/\{(\$[a-zA-Z_]*)$/)
+            : null;
+        const partialScopeName = partialScopeMatch ? partialScopeMatch[1] : '';
+        const partialSingleScopeName = partialSingleScopeMatch ? partialSingleScopeMatch[1] : '';
+        const envScopeMatch = linePrefix.match(/\{\{\$env\.([a-zA-Z_][a-zA-Z0-9_]*)?$/);
+        const singleEnvScopeMatch = !envScopeMatch
+            ? linePrefix.match(/\{\$env\.([a-zA-Z_][a-zA-Z0-9_]*)?$/)
+            : null;
+        const partialEnvVarName = envScopeMatch ? (envScopeMatch[1] || '') : '';
+        const partialSingleEnvVarName = singleEnvScopeMatch ? (singleEnvScopeMatch[1] || '') : '';
+        const closingBracesAhead = lineSuffix.match(/^\}+/);
+        const numClosingBraces = closingBracesAhead ? closingBracesAhead[0].length : 0;
+        const bracesToAdd = Math.max(0, 2 - numClosingBraces);
+        const closingBraces = '}'.repeat(bracesToAdd);
+        const buildEnvNamespaceItem = () => {
+            let insertText;
+            let range;
+            if (partialScopeName) {
+                insertText = new vscode.SnippetString(`\\$env.$0${closingBraces}`);
+                range = replacementRange(partialScopeName.length);
+            }
+            else if (partialSingleScopeName) {
+                insertText = new vscode.SnippetString(`{\\$env.$0${closingBraces}`);
+                range = replacementRange(partialSingleScopeName.length);
+            }
+            else if (endsWithDoubleBrace) {
+                insertText = new vscode.SnippetString(`\\$env.$0${closingBraces}`);
+            }
+            else if (endsWithSingleBrace) {
+                insertText = new vscode.SnippetString(`{\\$env.$0${closingBraces}`);
+            }
+            else {
+                insertText = new vscode.SnippetString(`{{\\$env.$0${closingBraces}`);
+            }
+            return this.createCompletionItem('$env', vscode.CompletionItemKind.Module, {
+                insertText,
+                range,
+                detail: 'Environment namespace',
+                documentation: new vscode.MarkdownString('**Environment namespace**\n\nUse `{{$env.name}}` to access an environment variable explicitly even when a file or local variable has the same name.'),
+                sortText: '0_$env',
+                command: this.createTriggerSuggestCommand('Suggest environment variables')
+            });
+        };
+        if (envScopeMatch || singleEnvScopeMatch) {
+            const envPartial = envScopeMatch ? partialEnvVarName : partialSingleEnvVarName;
+            const isSingleEnvScope = Boolean(singleEnvScopeMatch);
+            return Object.entries(envVariables)
+                .filter(([name]) => !envPartial || name.toLowerCase().startsWith(envPartial.toLowerCase()))
+                .map(([name, value]) => {
+                let range;
+                let insertText = name + closingBraces;
+                if (isSingleEnvScope) {
+                    range = replacementRange('$env.'.length + envPartial.length);
+                    insertText = `{$env.${name}${closingBraces}`;
+                }
+                else if (envPartial) {
+                    range = replacementRange(envPartial.length);
+                }
+                const shouldRedact = envSecretNames.has(name);
+                const displayValue = shouldRedact ? '***SECRET***' : value;
+                return this.createCompletionItem(name, vscode.CompletionItemKind.Constant, {
+                    insertText,
+                    range,
+                    detail: activeEnv ? `env:${activeEnv}` : 'env',
+                    documentation: new vscode.MarkdownString(`**Environment variable:** \`${name}\`\n\n` +
+                        `**Value:** \`${displayValue}\`\n\n` +
+                        `**Insert:** \`{{$env.${name}}}\``),
+                    sortText: `0_${name}`
+                });
+            });
+        }
+        if (partialScopeMatch || partialSingleScopeMatch) {
+            const scopePartial = partialScopeMatch ? partialScopeName : partialSingleScopeName;
+            return '$env'.startsWith(scopePartial) ? [buildEnvNamespaceItem()] : [];
+        }
+        if (allVariables.size === 0) {
+            return Object.keys(envVariables).length > 0 ? [buildEnvNamespaceItem()] : [];
+        }
+        const items = Array.from(allVariables.entries()).map(([name, { value, source }]) => {
+            const kind = source === 'env'
+                ? vscode.CompletionItemKind.Constant
+                : vscode.CompletionItemKind.Variable;
+            let insertText;
+            let range;
+            if (partialVarName) {
+                insertText = isSingleBracePartial
+                    ? '{' + name + closingBraces
+                    : name + closingBraces;
+                range = replacementRange(partialVarName.length);
+            }
+            else if (endsWithDoubleBrace) {
+                insertText = name + closingBraces;
+            }
+            else if (endsWithSingleBrace) {
+                insertText = '{' + name + closingBraces;
+            }
+            else {
+                insertText = '{{' + name + closingBraces;
+            }
+            const shouldRedact = source === 'env' && envSecretNames.has(name);
+            const displayValue = shouldRedact ? '***SECRET***' : value;
+            const detail = source === 'local'
+                ? 'local'
+                : `${source === 'env' ? `env${activeEnv ? `:${activeEnv}` : ''}` : 'file'}: ${displayValue}`;
+            const sourceDesc = source === 'env'
+                ? `**Source:** Environment${activeEnv ? ` (${activeEnv})` : ''}`
+                : source === 'local'
+                    ? '**Source:** Local sequence variable'
+                    : '**Source:** File';
+            const valueLine = source === 'local'
+                ? ''
+                : shouldRedact ? '**Value:** `***SECRET***`\n\n' : `**Value:** \`${value}\`\n\n`;
+            const explicitEnvLine = source === 'env'
+                ? `\n\n**Explicit env access:** \`{{$env.${name}}}\``
+                : '';
+            return this.createCompletionItem(name, kind, {
+                insertText,
+                range,
+                detail,
+                documentation: new vscode.MarkdownString(`**Variable:** \`${name}\`\n\n${valueLine}${sourceDesc}${explicitEnvLine}`),
+                sortText: source === 'local' ? `0_${name}` : source === 'file' ? `1_${name}` : `2_${name}`
+            });
+        });
+        if (Object.keys(envVariables).length > 0) {
+            items.unshift(buildEnvNamespaceItem());
+        }
+        return items;
+    }
+    // Check if the typed text could be the start of an HTTP method or keyword
+    couldBeMethodOrKeyword(text) {
+        if (text.length === 0) {
+            return false;
+        }
+        const lowerText = text.toLowerCase();
+        const allKeywords = [...this.httpMethods.map(m => m.toLowerCase()), ...this.keywords];
+        return allKeywords.some(kw => kw.startsWith(lowerText));
+    }
+    getMethodCompletions(typedText) {
+        const lowerTyped = typedText?.toLowerCase() || '';
+        return this.httpMethods
+            .filter(method => !lowerTyped || method.toLowerCase().startsWith(lowerTyped))
+            .map(method => {
+            return this.createCompletionItem(method, vscode.CompletionItemKind.Keyword, {
+                insertText: method,
+                documentation: `HTTP ${method} request`,
+                sortText: '0_' + method,
+                preselect: lowerTyped && method.toLowerCase().startsWith(lowerTyped) ? true : undefined
+            });
+        });
+    }
+    getKeywordCompletions() {
+        const keywordItems = [
+            {
+                label: 'var',
+                options: {
+                    insertText: 'var ',
+                    documentation: new vscode.MarkdownString('Declare a variable.\n\n`var myVar = someValue`\n\nReference with `{{myVar}}`'),
+                    sortText: '1_var'
+                }
+            },
+            {
+                label: 'sequence',
+                options: {
+                    insertText: new vscode.SnippetString('sequence $0\n\nend sequence'),
+                    documentation: new vscode.MarkdownString('Define a sequence of requests to run together.\n\n```\nsequence auth-flow\n\nPOST /login\n...\n\nvar token = $1.accessToken\n\nGET /profile\n...\n\nend sequence\n```'),
+                    sortText: '1_sequence'
+                }
+            },
+            {
+                label: 'test sequence',
+                options: {
+                    insertText: new vscode.SnippetString('test sequence $0\n\nend sequence'),
+                    documentation: new vscode.MarkdownString('Define a test sequence (discoverable in Test Explorer and runnable via CLI).\n\n' +
+                        '```\n' +
+                        'test sequence MyTest\n' +
+                        '\n' +
+                        'GET /health\n' +
+                        'assert $1.status == 200\n' +
+                        '\n' +
+                        'end sequence\n' +
+                        '```'),
+                    sortText: '1_test_sequence'
+                }
+            },
+            {
+                label: 'end sequence',
+                options: {
+                    insertText: 'end sequence',
+                    documentation: 'End a sequence block',
+                    sortText: '1_end_sequence'
+                }
+            },
+            {
+                label: 'run bash',
+                options: {
+                    insertText: 'run bash ',
+                    documentation: new vscode.MarkdownString('Execute a bash script.\n\n```\nrun bash ./scripts/seed-db.sh\n\n# Or capture output:\nvar result = run bash ./scripts/generate.sh arg1\n```\n\nVariables are passed as `NORN_VARNAME` environment variables.'),
+                    sortText: '1_run_bash'
+                }
+            },
+            {
+                label: 'run powershell',
+                options: {
+                    insertText: 'run powershell ',
+                    documentation: new vscode.MarkdownString('Execute a PowerShell script.\n\n```\nrun powershell ./scripts/setup.ps1\n\n# Or capture output:\nvar token = run powershell ./scripts/get-token.ps1\n```\n\nVariables are passed as `NORN_VARNAME` environment variables.'),
+                    sortText: '1_run_powershell'
+                }
+            },
+            {
+                label: 'run js',
+                options: {
+                    insertText: 'run js ',
+                    documentation: new vscode.MarkdownString('Execute a Node.js script.\n\n```\nrun js ./scripts/transform.js\n\n# Or capture output:\nvar signature = run js ./scripts/sign.js {{payload}}\n```\n\nVariables are passed as `NORN_VARNAME` environment variables and also as `NORN_VARIABLES` JSON.'),
+                    sortText: '1_run_js'
+                }
+            },
+            {
+                label: 'run',
+                options: {
+                    insertText: 'run ',
+                    documentation: new vscode.MarkdownString('Run a named request or script.\n\n**Run a named request:**\n```\nrun MyRequest\n```\n\n**Run a script:**\n```\nrun bash ./script.sh\nrun powershell ./script.ps1\nrun js ./script.js\n```'),
+                    sortText: '1_run'
+                }
+            },
+            {
+                label: 'print',
+                options: {
+                    insertText: 'print ',
+                    documentation: new vscode.MarkdownString('Print a message to the result view.\n\n**Simple message (title only):**\n```\nprint Starting authentication flow...\nprint User ID: {{userId}}\n```\n\n**With expandable body:**\n```\nprint Request Details | Method: POST, URL: {{url}}\nprint Debug Info | Token: {{token}}, Expires: {{expiry}}\n```\n\nVariables are substituted in both title and body. Use `|` to separate title from body content.'),
+                    sortText: '1_print'
+                }
+            },
+            {
+                label: 'assert',
+                options: {
+                    insertText: 'assert ',
+                    documentation: new vscode.MarkdownString('Assert a condition on the response. Fails the sequence if the assertion is false.\n\n' +
+                        '**Check status code:**\n```norn\nassert $1.status == 200\nassert $1.status >= 200\nassert $1.status < 400\n```\n\n' +
+                        '**Check response body:**\n```norn\nassert $1.body.success == true\nassert $1.body.name == "John"\nassert $1.body.email contains "@"\n```\n\n' +
+                        '**Check type:**\n```norn\nassert $1.body.id isType number\nassert $1.body.items isType array\nassert $1.body.user isType object\n```\n\n' +
+                        '**Validate schema:**\n```norn\nassert $1.body matchesSchema "./schemas/user.schema.json"\nassert user.body matchesSchema "./schemas/response.schema.json"\n```\n\n' +
+                        '**Check headers:**\n```norn\nassert $1.headers.Content-Type contains "json"\n```\n\n' +
+                        '**Check existence:**\n```norn\nassert $1.body.token exists\nassert $1.body.error !exists\n```\n\n' +
+                        '**With custom message:**\n```norn\nassert $1.status == 200 | "Login should succeed"\n```\n\n' +
+                        '**Operators:** `==`, `!=`, `>`, `>=`, `<`, `<=`, `contains`, `startsWith`, `endsWith`, `matches`, `matchesSchema`, `exists`, `!exists`, `isType`\n\n' +
+                        '**Types for isType:** `number`, `string`, `boolean`, `object`, `array`, `null`'),
+                    sortText: '1_assert'
+                }
+            },
+            {
+                label: 'if',
+                options: {
+                    documentation: 'Conditional execution based on response values',
+                    sortText: '1_if'
+                }
+            },
+            {
+                label: 'end if',
+                options: {
+                    documentation: 'End an if conditional block',
+                    sortText: '1_end_if'
+                }
+            },
+            {
+                label: 'wait',
+                options: {
+                    documentation: 'Pause execution for a specified duration (e.g., wait 1s, wait 500ms)',
+                    sortText: '1_wait'
+                }
+            },
+            {
+                label: 'run readJson',
+                options: {
+                    insertText: 'run readJson',
+                    documentation: new vscode.MarkdownString('Load a JSON file into a variable for use in your requests.\n\n' +
+                        '**Load a JSON file:**\n```norn\nvar config = run readJson ./config.json\nvar testData = run readJson "./data/users.json"\n```\n\n' +
+                        '**Access properties:**\n```norn\n# After loading: var data = run readJson ./test-data.json\n\n' +
+                        '# Use top-level properties\nGET {{data.baseUrl}}/users\n\n' +
+                        '# Access nested properties\nContent-Type: {{data.headers.contentType}}\n\n' +
+                        '# Access array elements\nprint User: {{data.users[0].name}}\n```\n\n' +
+                        'Supports deep nesting with dot notation and array indexing `[n]`.'),
+                    sortText: '1_run_readJson'
+                }
+            },
+            {
+                label: 'import',
+                options: {
+                    insertText: new vscode.SnippetString('import "$0"'),
+                    documentation: new vscode.MarkdownString('Import named requests and sequences from another .norn file.\n\n' +
+                        '**Import a file:**\n```norn\nimport "./common/auth.norn"\nimport "./shared/utils.norn"\n```\n\n' +
+                        '**Use imported requests and sequences:**\n```norn\nimport "./common.norn"\n\nsequence MyFlow\n    run SharedRequest\n    run SharedSequence\nend sequence\n```\n\n' +
+                        'Imported definitions are available throughout the file.'),
+                    sortText: '1_import'
+                }
+            }
+        ];
+        return keywordItems.map(({ label, options }) => this.createCompletionItem(label, vscode.CompletionItemKind.Keyword, options));
+    }
+    getHeaderCompletions() {
+        return this.commonHeaders.map(header => {
+            return this.createCompletionItem(header, vscode.CompletionItemKind.Field, {
+                insertText: `${header}: `,
+                documentation: `HTTP header: ${header}`,
+                // Trigger IntelliSense again after inserting the header (for Content-Type values, etc.)
+                command: this.createTriggerSuggestCommand()
+            });
+        });
+    }
+    getContentTypeCompletions() {
+        return this.contentTypes.map(type => {
+            return this.createCompletionItem(type, vscode.CompletionItemKind.Value, {
+                documentation: `Content type: ${type}`
+            });
+        });
+    }
+    startsWithMethod(text) {
+        const trimmed = text.trim().toUpperCase();
+        return this.httpMethods.some(method => trimmed.startsWith(method));
+    }
+    /**
+     * Check if user is typing after "var x = " (for run command or variable completion)
+     * Does NOT match if already past an endpoint (header group context)
+     */
+    isTypingVarAssignment(linePrefix) {
+        const trimmed = linePrefix.trim();
+        // Match "var name = " or "var name = r" or "var name = run" etc.
+        const match = trimmed.match(/^var\s+[a-zA-Z_][a-zA-Z0-9_]*\s*=\s*(.*)$/i);
+        if (!match) {
+            return false;
+        }
+        const afterEquals = match[1];
+        // Don't trigger if inside a quoted string
+        if (afterEquals.startsWith('"') || afterEquals.startsWith("'")) {
+            return false;
+        }
+        // Don't trigger if we're past an HTTP method + endpoint (that's header group context)
+        // Pattern: GET EndpointName(params) followed by space
+        const httpEndpointPattern = /^(GET|POST|PUT|DELETE|PATCH|HEAD|OPTIONS)\s+[a-zA-Z_][a-zA-Z0-9_]*(?:\([^)]*\))?\s+/i;
+        if (httpEndpointPattern.test(afterEquals)) {
+            return false;
+        }
+        // Trigger for any text after equals (including empty to show completions)
+        return true;
+    }
+    /**
+     * Get completions when inside "var x = " assignment
+     * Shows: run commands, HTTP methods (for var x = GET endpoint), defined variables, and keywords
+     */
+    getRunCompletionsForVarAssignment(document, linePrefix) {
+        const trimmed = linePrefix.trim();
+        const match = trimmed.match(/^var\s+[a-zA-Z_][a-zA-Z0-9_]*\s*=\s*(.*)$/i);
+        const afterEquals = match ? match[1] : '';
+        const items = [];
+        // Add HTTP methods for "var x = GET endpoint" pattern
+        for (const method of this.httpMethods) {
+            if (afterEquals === '' || method.toLowerCase().startsWith(afterEquals.toLowerCase())) {
+                items.push(this.createCompletionItem(method, vscode.CompletionItemKind.Method, {
+                    insertText: method,
+                    detail: `Capture ${method} response into variable`,
+                    documentation: new vscode.MarkdownString(`Capture an HTTP response into a variable for assertions.\n\n` +
+                        `**Examples:**\n` +
+                        `- \`var user = ${method} {{baseUrl}}/users/1\`\n` +
+                        `- \`var user = ${method} GetUser(1) Json\`\n\n` +
+                        `Then use: \`assert user.body.id == 1\``),
+                    sortText: `0_${method}`
+                }));
+            }
+        }
+        // Handle 'run' keyword - only show script types (bash, powershell, etc.) after user types "run "
+        const lowerAfter = afterEquals.toLowerCase();
+        // Check if line ends with space after 'run' - the original linePrefix preserves trailing space
+        const hasTrailingSpace = linePrefix.endsWith(' ');
+        const typedRunWithSpace = (lowerAfter === 'run' && hasTrailingSpace) || lowerAfter.startsWith('run ');
+        if (typedRunWithSpace) {
+            // User typed "var x = run " - show script types and named requests
+            items.push(...this.getRunCompletions(document, afterEquals, linePrefix));
+        }
+        else if (afterEquals === '' || 'run'.startsWith(lowerAfter)) {
+            // User typed "var x = " or "var x = r" or "var x = ru" or "var x = run" (no space) - just show 'run' keyword
+            items.push(this.createCompletionItem('run', vscode.CompletionItemKind.Keyword, {
+                insertText: 'run ',
+                detail: 'Run a script or named request',
+                documentation: new vscode.MarkdownString('Run a script or named request to capture its result.\n\n' +
+                    '**Scripts:**\n```norn\nvar result = run bash ./script.sh\nvar data = run readJson ./data.json\n```\n\n' +
+                    '**Named requests:**\n```norn\nvar user = run GetUser\n```'),
+                sortText: '0_run',
+                command: this.createTriggerSuggestCommand()
+            }));
+        }
+        // Also show variable completions if not typing 'run' or HTTP method
+        const isTypingMethod = this.httpMethods.some(m => afterEquals.toLowerCase().startsWith(m.toLowerCase()));
+        if (!afterEquals.toLowerCase().startsWith('run') && !isTypingMethod) {
+            items.push(...this.getVariablePathCompletions(document, afterEquals));
+        }
+        // Add literal keywords
+        if (afterEquals === '' || 'true'.startsWith(afterEquals.toLowerCase())) {
+            items.push(this.createCompletionItem('true', vscode.CompletionItemKind.Keyword, {
+                detail: 'Boolean true'
+            }));
+        }
+        if (afterEquals === '' || 'false'.startsWith(afterEquals.toLowerCase())) {
+            items.push(this.createCompletionItem('false', vscode.CompletionItemKind.Keyword, {
+                detail: 'Boolean false'
+            }));
+        }
+        if (afterEquals === '' || 'null'.startsWith(afterEquals.toLowerCase())) {
+            items.push(this.createCompletionItem('null', vscode.CompletionItemKind.Keyword, {
+                detail: 'Null value'
+            }));
+        }
+        return items;
+    }
+    /**
+     * Get variable path completions for var assignment (e.g., data, data.users, etc.)
+     */
+    getVariablePathCompletions(document, prefix) {
+        const fullText = document.getText();
+        const fileVariables = (0, parser_1.extractVariables)(fullText);
+        const envVariables = (0, environmentProvider_1.getEnvironmentVariables)(document.uri.fsPath);
+        const envSecretNames = (0, environmentProvider_1.getEnvironmentSecretNames)(document.uri.fsPath);
+        const allVariables = { ...envVariables, ...fileVariables };
+        const items = [];
+        const lowerPrefix = prefix.toLowerCase();
+        for (const [name, value] of Object.entries(allVariables)) {
+            // Filter by prefix if user has typed something
+            if (lowerPrefix && !name.toLowerCase().startsWith(lowerPrefix)) {
+                continue;
+            }
+            const isSecret = envSecretNames.has(name) && envVariables[name] !== undefined;
+            const displayValue = isSecret ? '***SECRET***' : value.length > 50 ? value.substring(0, 47) + '...' : value;
+            let detail = displayValue;
+            let documentation = isSecret ? `Variable: ${name} (secret)` : `Variable: ${name}`;
+            // If the value is JSON, indicate it can be accessed with paths
+            if (!isSecret) {
+                try {
+                    const parsed = JSON.parse(value);
+                    if (typeof parsed === 'object' && parsed !== null) {
+                        documentation = `JSON variable - access properties with ${name}.property`;
+                        detail = 'JSON object';
+                    }
+                }
+                catch {
+                    // Not JSON, use value as detail
+                }
+            }
+            items.push(this.createCompletionItem(name, vscode.CompletionItemKind.Variable, {
+                detail,
+                documentation
+            }));
+        }
+        return items;
+    }
+    /**
+     * Check if user is typing "run" or after "run " (for named request completion)
+     */
+    isTypingRunCommand(linePrefix) {
+        const lowerPrefix = linePrefix.toLowerCase();
+        const trimmed = lowerPrefix.trim();
+        // Check if user is typing 'r', 'ru', or 'run' at the start of a line
+        if (trimmed && 'run'.startsWith(trimmed)) {
+            return true;
+        }
+        // Check if line is exactly "run" followed by space (user just typed "run ")
+        // Use the original linePrefix to detect trailing space
+        if (trimmed === 'run' && lowerPrefix.endsWith(' ')) {
+            return true;
+        }
+        // Check if line starts with "run " and has more content
+        if (!trimmed.startsWith('run ')) {
+            return false;
+        }
+        const afterRun = trimmed.substring(4).trim();
+        // Don't trigger for script commands that already have a path
+        if (/^(bash|js|powershell|readjson)\s+\S/i.test(afterRun)) {
+            return false;
+        }
+        return true;
+    }
+    isTypingRunSqlCommand(linePrefix) {
+        const trimmed = linePrefix.trim();
+        if (/^(?:var\s+[a-zA-Z_][a-zA-Z0-9_]*\s*=\s*)?run\s+sql\s*$/i.test(trimmed) && linePrefix.endsWith(' ')) {
+            return true;
+        }
+        return /^(?:var\s+[a-zA-Z_][a-zA-Z0-9_]*\s*=\s*)?run\s+sql\s+[a-zA-Z_][a-zA-Z0-9_-]*$/i.test(trimmed);
+    }
+    isTypingRunMcpCommand(linePrefix) {
+        const trimmed = linePrefix.trim();
+        if (!/^(?:var\s+[a-zA-Z_][a-zA-Z0-9_]*\s*=\s*)?run\s+mcp(?:\s+.*)?$/i.test(trimmed)) {
+            return false;
+        }
+        if (/^(?:var\s+[a-zA-Z_][a-zA-Z0-9_]*\s*=\s*)?run\s+mcp\s*$/i.test(trimmed)) {
+            return true;
+        }
+        return true;
+    }
+    getMcpServerAliasCompletions(document, typedAlias, operation) {
+        try {
+            const config = (0, mcpConfig_1.loadNornMcpProjectConfig)(document.uri.fsPath);
+            const items = [];
+            const lowerTypedAlias = typedAlias.toLowerCase();
+            for (const [alias, server] of Object.entries(config.config.servers)) {
+                if (lowerTypedAlias && !alias.toLowerCase().startsWith(lowerTypedAlias)) {
+                    continue;
+                }
+                items.push(this.createCompletionItem(alias, vscode.CompletionItemKind.Module, {
+                    insertText: operation === 'call' ? `${alias} ` : alias,
+                    detail: `MCP ${server.transport} server`,
+                    documentation: new vscode.MarkdownString(`**MCP Server:** \`${alias}\`\n\nTransport: \`${server.transport}\``),
+                    sortText: `0_${alias.toLowerCase()}`,
+                    command: operation === 'call' ? this.createTriggerSuggestCommand() : undefined
+                }));
+            }
+            return items;
+        }
+        catch {
+            return [];
+        }
+    }
+    resolveKnownMcpAlias(document, alias) {
+        try {
+            const config = (0, mcpConfig_1.loadNornMcpProjectConfig)(document.uri.fsPath);
+            return Object.keys(config.config.servers).find(candidate => candidate.toLowerCase() === alias.toLowerCase());
+        }
+        catch {
+            return undefined;
+        }
+    }
+    buildMcpToolDocumentation(tool) {
+        const parameterNames = (0, mcpToolSchema_1.getMcpToolInputParameterNames)(tool);
+        const propertyMap = (0, mcpToolSchema_1.getMcpToolInputPropertyMap)(tool);
+        const required = new Set((0, mcpToolSchema_1.getMcpToolRequiredParameterNames)(tool).map(name => name.toLowerCase()));
+        const lines = [`**MCP Tool:** \`${tool.name}\``];
+        if (tool.description) {
+            lines.push('', tool.description);
+        }
+        if (parameterNames.length === 0) {
+            lines.push('', 'Parameters: none');
+        }
+        else {
+            lines.push('', 'Parameters:');
+            for (const name of parameterNames) {
+                const typeSummary = this.getMcpParameterTypeSummary(propertyMap[name]);
+                lines.push(`- \`${name}\`${required.has(name.toLowerCase()) ? ' required' : ''}${typeSummary ? ` · ${typeSummary}` : ''}`);
+            }
+        }
+        lines.push('', 'Available from a previous `run mcp list` call cached in `.norn-cache`.');
+        return new vscode.MarkdownString(lines.join('\n'));
+    }
+    getMcpParameterTypeSummary(schema) {
+        if (!schema || typeof schema !== 'object' || Array.isArray(schema)) {
+            return undefined;
+        }
+        const candidate = schema;
+        if (Array.isArray(candidate.enum) && candidate.enum.length > 0) {
+            return 'enum';
+        }
+        if (typeof candidate.type === 'string') {
+            if (candidate.type === 'array') {
+                const itemType = this.getMcpParameterTypeSummary(candidate.items);
+                return itemType ? `array<${itemType}>` : 'array';
+            }
+            return candidate.type;
+        }
+        if (Array.isArray(candidate.type)) {
+            const types = candidate.type.filter((entry) => typeof entry === 'string');
+            return types.length > 0 ? types.join(' | ') : undefined;
+        }
+        if (candidate.properties && typeof candidate.properties === 'object' && !Array.isArray(candidate.properties)) {
+            return 'object';
+        }
+        if (candidate.items) {
+            return 'array';
+        }
+        return undefined;
+    }
+    getMcpCallToolCompletions(document, linePrefix) {
+        const trimmed = linePrefix.trim();
+        const afterAliasMatch = trimmed.match(/^(?:var\s+[a-zA-Z_][a-zA-Z0-9_]*\s*=\s*)?run\s+mcp\s+call\s+([a-zA-Z_][a-zA-Z0-9_-]*)$/i);
+        const typedToolMatch = trimmed.match(/^(?: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_.:-]*)$/i);
+        let alias;
+        let typedToolName = '';
+        if (afterAliasMatch && linePrefix.endsWith(' ')) {
+            alias = afterAliasMatch[1];
+        }
+        else if (typedToolMatch) {
+            alias = typedToolMatch[1];
+            typedToolName = typedToolMatch[2];
+        }
+        if (!alias) {
+            return [];
+        }
+        const resolvedAlias = this.resolveKnownMcpAlias(document, alias);
+        if (!resolvedAlias) {
+            return [];
+        }
+        const cachedTools = (0, mcpToolIntellisenseCache_1.getCachedMcpToolsForAlias)(document.uri.fsPath, resolvedAlias);
+        if (!cachedTools) {
+            return [];
+        }
+        const lowerTypedToolName = typedToolName.toLowerCase();
+        return cachedTools.tools
+            .filter(tool => !lowerTypedToolName || tool.name.toLowerCase().startsWith(lowerTypedToolName))
+            .map(tool => {
+            const parameterNames = (0, mcpToolSchema_1.getMcpToolInputParameterNames)(tool);
+            return this.createCompletionItem(tool.name, vscode.CompletionItemKind.Function, {
+                insertText: parameterNames.length > 0
+                    ? new vscode.SnippetString(`${tool.name}($0)`)
+                    : new vscode.SnippetString(`${tool.name}()$0`),
+                detail: parameterNames.length > 0
+                    ? `MCP tool · ${parameterNames.length} parameter${parameterNames.length === 1 ? '' : 's'}`
+                    : 'MCP tool',
+                documentation: this.buildMcpToolDocumentation(tool),
+                sortText: `0_${tool.name.toLowerCase()}`,
+                command: parameterNames.length > 0
+                    ? {
+                        command: TRIGGER_PARAMETER_HINTS_COMMAND,
+                        title: 'Trigger Parameter Hints'
+                    }
+                    : undefined
+            });
+        });
+    }
+    getMcpArgumentCompletionContext(argsPrefix) {
+        const usedNamedArgs = new Set();
+        const parts = (0, sequenceRunner_1.splitNamedArgumentList)(argsPrefix);
+        const endsWithComma = /,\s*$/.test(argsPrefix);
+        const completedParts = endsWithComma ? parts : parts.slice(0, -1);
+        const currentPart = endsWithComma ? '' : (parts.at(-1) ?? '');
+        for (const part of completedParts) {
+            const match = part.trim().match(/^([a-zA-Z_][a-zA-Z0-9_]*)\s*:/);
+            if (match) {
+                usedNamedArgs.add(match[1].toLowerCase());
+            }
+        }
+        const currentTrimmed = currentPart.trim();
+        if (!currentTrimmed) {
+            return {
+                canSuggest: true,
+                currentNamePrefix: '',
+                usedNamedArgs
+            };
+        }
+        if (currentTrimmed.includes(':')) {
+            return {
+                canSuggest: false,
+                currentNamePrefix: '',
+                usedNamedArgs
+            };
+        }
+        if (/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(currentTrimmed)) {
+            return {
+                canSuggest: true,
+                currentNamePrefix: currentTrimmed,
+                usedNamedArgs
+            };
+        }
+        return {
+            canSuggest: false,
+            currentNamePrefix: '',
+            usedNamedArgs
+        };
+    }
+    getMcpCallParameterCompletions(document, linePrefix) {
+        const match = linePrefix.match(/^(?: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_.:-]*)\((.*)$/i);
+        if (!match) {
+            return [];
+        }
+        const argsPrefix = match[3];
+        if (argsPrefix.includes(')')) {
+            return [];
+        }
+        const resolvedAlias = this.resolveKnownMcpAlias(document, match[1]);
+        if (!resolvedAlias) {
+            return [];
+        }
+        const cachedTool = (0, mcpToolIntellisenseCache_1.getCachedMcpToolForAlias)(document.uri.fsPath, resolvedAlias, match[2]);
+        if (!cachedTool) {
+            return [];
+        }
+        const parameterNames = (0, mcpToolSchema_1.getMcpToolInputParameterNames)(cachedTool);
+        if (parameterNames.length === 0) {
+            return [];
+        }
+        const completionContext = this.getMcpArgumentCompletionContext(argsPrefix);
+        if (!completionContext.canSuggest) {
+            return [];
+        }
+        const propertyMap = (0, mcpToolSchema_1.getMcpToolInputPropertyMap)(cachedTool);
+        const required = new Set((0, mcpToolSchema_1.getMcpToolRequiredParameterNames)(cachedTool).map(name => name.toLowerCase()));
+        const lowerPrefix = completionContext.currentNamePrefix.toLowerCase();
+        return parameterNames
+            .filter(name => !completionContext.usedNamedArgs.has(name.toLowerCase()))
+            .filter(name => !lowerPrefix || name.toLowerCase().startsWith(lowerPrefix))
+            .map(name => {
+            const typeSummary = this.getMcpParameterTypeSummary(propertyMap[name]);
+            const isRequired = required.has(name.toLowerCase());
+            return this.createCompletionItem(name, vscode.CompletionItemKind.Property, {
+                insertText: `${name}: `,
+                detail: `${isRequired ? 'Required' : 'Optional'} parameter${typeSummary ? ` · ${typeSummary}` : ''}`,
+                documentation: new vscode.MarkdownString(`**${name}**\n\n` +
+                    `${isRequired ? 'Required' : 'Optional'} parameter` +
+                    `${typeSummary ? `\n\nType: \`${typeSummary}\`` : ''}`),
+                sortText: `${isRequired ? '0' : '1'}_${name.toLowerCase()}`
+            });
+        });
+    }
+    getMcpCompletions(document, linePrefix) {
+        const trimmed = linePrefix.trim();
+        const match = trimmed.match(/^(?:var\s+[a-zA-Z_][a-zA-Z0-9_]*\s*=\s*)?run\s+mcp(?:\s+(.*))?$/i);
+        if (!match) {
+            return [];
+        }
+        const afterMcp = match[1] || '';
+        const normalized = afterMcp.trim();
+        const hasTrailingSpace = linePrefix.endsWith(' ');
+        const tokens = normalized ? normalized.split(/\s+/) : [];
+        if (tokens.length === 0 || (tokens.length === 1 && !hasTrailingSpace)) {
+            const typedOperation = tokens[0]?.toLowerCase() || '';
+            return [
+                {
+                    name: 'list',
+                    detail: 'List tools from an MCP server alias',
+                    documentation: 'List the tools exposed by a configured MCP server.',
+                    sortText: '0_list'
+                },
+                {
+                    name: 'call',
+                    detail: 'Call a tool on an MCP server alias',
+                    documentation: 'Call a specific tool on a configured MCP server.',
+                    sortText: '0_call'
+                }
+            ]
+                .filter(entry => !typedOperation || entry.name.startsWith(typedOperation))
+                .map(entry => {
+                return this.createCompletionItem(entry.name, vscode.CompletionItemKind.Method, {
+                    insertText: `${entry.name} `,
+                    detail: entry.detail,
+                    documentation: new vscode.MarkdownString(entry.documentation),
+                    sortText: entry.sortText,
+                    command: this.createTriggerSuggestCommand()
+                });
+            });
+        }
+        const operation = tokens[0]?.toLowerCase();
+        if (operation === 'call') {
+            const toolCompletions = this.getMcpCallToolCompletions(document, linePrefix);
+            if (toolCompletions.length > 0) {
+                return toolCompletions;
+            }
+        }
+        if ((operation === 'list' || operation === 'call') && ((tokens.length === 1 && hasTrailingSpace) || (tokens.length === 2 && !hasTrailingSpace))) {
+            return this.getMcpServerAliasCompletions(document, tokens[1] || '', operation);
+        }
+        return [];
+    }
+    getSqlOperationCompletions(document, linePrefix) {
+        const trimmed = linePrefix.trim();
+        const match = trimmed.match(/^(?:var\s+[a-zA-Z_][a-zA-Z0-9_]*\s*=\s*)?run\s+sql(?:\s+([a-zA-Z_][a-zA-Z0-9_-]*))?$/i);
+        const typedName = (match?.[1] || '').toLowerCase();
+        const importedSql = this.getImportedSqlDefinitions(document);
+        const items = [];
+        const seen = new Set();
+        for (const entry of importedSql.operations) {
+            const operation = entry.operation;
+            const lowerName = operation.name.toLowerCase();
+            if (seen.has(lowerName)) {
+                continue;
+            }
+            if (typedName && !lowerName.startsWith(typedName)) {
+                continue;
+            }
+            seen.add(lowerName);
+            items.push(this.createCompletionItem(operation.name, vscode.CompletionItemKind.Function, {
+                insertText: operation.parameters.length > 0
+                    ? new vscode.SnippetString(`${operation.name}($0)`)
+                    : operation.name,
+                detail: `${operation.type} · ${path.basename(entry.sourcePath)}`,
+                documentation: new vscode.MarkdownString(`**${operation.type}** \`${operation.name}\`\n\n` +
+                    `Connection: \`${operation.connectionName}\`\n\n` +
+                    (operation.parameters.length > 0
+                        ? `Parameters: ${operation.parameters.map(param => `\`${param}\``).join(', ')}\n\n`
+                        : 'Parameters: none\n\n') +
+                    '```sql\n' + operation.sql.substring(0, 300) + (operation.sql.length > 300 ? '...' : '') + '\n```'),
+                sortText: `0_${operation.name}`
+            }));
+        }
+        return items;
+    }
+    /**
+     * Get completions for named requests and script types after "run "
+     */
+    getNamedRequestCompletions(document, linePrefix) {
+        const trimmed = linePrefix.trim();
+        // Use shared logic for run completions
+        return this.getRunCompletions(document, trimmed, linePrefix);
+    }
+    /**
+     * Shared logic for run command completions - used by both standalone "run" and "var x = run"
+     */
+    getRunCompletions(document, textAfterContext, originalLinePrefix) {
+        const fullText = document.getText();
+        const localNamedRequests = (0, parser_1.extractNamedRequests)(fullText);
+        const localSequences = (0, sequenceRunner_1.extractSequences)(fullText);
+        const importedDefinitions = this.getImportedRunDefinitions(document);
+        const items = [];
+        const lowerText = textAfterContext.toLowerCase().trim();
+        const namedRequests = [];
+        const seenNamedRequests = new Set();
+        for (const request of localNamedRequests) {
+            const lowerName = request.name.toLowerCase();
+            if (seenNamedRequests.has(lowerName)) {
+                continue;
+            }
+            seenNamedRequests.add(lowerName);
+            namedRequests.push({ request, source: 'local' });
+        }
+        for (const imported of importedDefinitions.namedRequests) {
+            const lowerName = imported.request.name.toLowerCase();
+            if (seenNamedRequests.has(lowerName)) {
+                continue;
+            }
+            seenNamedRequests.add(lowerName);
+            namedRequests.push({ request: imported.request, source: 'imported', sourcePath: imported.sourcePath });
+        }
+        const sequences = [];
+        const seenSequences = new Set();
+        for (const sequence of localSequences) {
+            const lowerName = sequence.name.toLowerCase();
+            if (seenSequences.has(lowerName)) {
+                continue;
+            }
+            seenSequences.add(lowerName);
+            sequences.push({ sequence, source: 'local' });
+        }
+        for (const imported of importedDefinitions.sequences) {
+            const lowerName = imported.sequence.name.toLowerCase();
+            if (seenSequences.has(lowerName)) {
+                continue;
+            }
+            seenSequences.add(lowerName);
+            sequences.push({ sequence: imported.sequence, source: 'imported', sourcePath: imported.sourcePath });
+        }
+        // Check if user typed 'run' exactly without trailing space
+        // VS Code filters completions by the word being typed, so 'bash' won't show when user typed 'run'
+        // We need to show 'run' as a completion that adds a space and retriggers
+        const typedRunExactly = (lowerText === 'run' || 'run'.startsWith(lowerText)) && lowerText.length > 0 && !originalLinePrefix.endsWith(' ');
+        if (typedRunExactly) {
+            items.push(this.createCompletionItem('run', vscode.CompletionItemKind.Method, {
+                insertText: 'run ',
+                documentation: new vscode.MarkdownString('Execute a script, named request, SQL operation, or MCP command\n\n**Options:** `bash`, `powershell`, `js`, `readJson`, `sql`, `mcp`, or a sequence name'),
+                sortText: '0_run',
+                // Trigger IntelliSense again after inserting 'run '
+                command: this.createTriggerSuggestCommand()
+            }));
+            return items;
+        }
+        // Determine what's after "run " (if anything)
+        let afterRun = '';
+        if (lowerText === 'run' || lowerText === '') {
+            afterRun = '';
+        }
+        else if (lowerText.startsWith('run ')) {
+            afterRun = lowerText.substring(4).trim();
+        }
+        else {
+            // Might be starting fresh (empty context)
+            afterRun = '';
+        }
+        // Add script type completions (bash, powershell, js, readJson)
+        const scriptTypes = [
+            { name: 'bash', doc: 'Execute a bash script' },
+            { name: 'powershell', doc: 'Execute a PowerShell script' },
+            { name: 'js', doc: 'Execute a Node.js script' },
+            { name: 'readJson', doc: 'Load a JSON file. Access properties with {{var.property}}' },
+            { name: 'sql', doc: 'Run a named SQL query or command from an imported .nornsql file' },
+            { name: 'mcp', doc: 'List tools or call a tool from a configured MCP server' },
+        ];
+        for (const st of scriptTypes) {
+            if (!afterRun || st.name.toLowerCase().startsWith(afterRun.toLowerCase())) {
+                items.push(this.createCompletionItem(st.name, vscode.CompletionItemKind.Method, {
+                    insertText: st.name + ' ',
+                    documentation: new vscode.MarkdownString(st.doc),
+                    sortText: `0_${st.name}`,
+                    command: st.name === 'sql' || st.name === 'mcp'
+                        ? this.createTriggerSuggestCommand()
+                        : undefined
+                }));
+            }
+        }
+        // Add named request completions
+        for (const entry of namedRequests) {
+            const req = entry.request;
+            if (afterRun && !req.name.toLowerCase().startsWith(afterRun)) {
+                continue;
+            }
+            // Show the request method and URL in detail
+            const methodMatch = req.content.match(/^(GET|POST|PUT|DELETE|PATCH|HEAD|OPTIONS)\s+(.+)/im);
+            const sourceSuffix = entry.source === 'imported' && entry.sourcePath
+                ? ` (imported: ${path.basename(entry.sourcePath)})`
+                : '';
+            let detail;
+            if (methodMatch) {
+                detail = `${methodMatch[1]} ${methodMatch[2].split('\n')[0]}${sourceSuffix}`;
+            }
+            else if (sourceSuffix) {
+                detail = `Named request${sourceSuffix}`;
+            }
+            items.push(this.createCompletionItem(req.name, vscode.CompletionItemKind.Function, {
+                insertText: req.name,
+                detail,
+                documentation: new vscode.MarkdownString(`**Named Request:** \`${req.name}\`\n\n` +
+                    '```http\n' + req.content.substring(0, 200) + (req.content.length > 200 ? '...' : '') + '\n```' +
+                    (entry.source === 'imported' && entry.sourcePath
+                        ? `\n\n**Source:** \`${entry.sourcePath}\``
+                        : '')),
+                sortText: entry.source === 'local'
+                    ? `1_${req.name}`
+                    : `1z_${req.name}`
+            }));
+        }
+        // Add sequence completions
+        for (const entry of sequences) {
+            const seq = entry.sequence;
+            if (afterRun && !seq.name.toLowerCase().startsWith(afterRun)) {
+                continue;
+            }
+            const sequenceType = seq.isTest ? 'Test Sequence' : 'Sequence';
+            const sourceSuffix = entry.source === 'imported' && entry.sourcePath
+                ? ` (imported: ${path.basename(entry.sourcePath)})`
+                : '';
+            // Count steps in the sequence for info
+            const stepCount = seq.content.split('\n').filter(l => l.trim() !== '').length;
+            items.push(this.createCompletionItem(seq.name, vscode.CompletionItemKind.Module, {
+                insertText: seq.name,
+                detail: `${sequenceType}${sourceSuffix}`,
+                documentation: new vscode.MarkdownString(`**Sequence:** \`${seq.name}\`\n\n` +
+                    `~${stepCount} steps\n\n` +
+                    'Run this sequence. Variables set in the sequence will be available after it completes.' +
+                    (entry.source === 'imported' && entry.sourcePath
+                        ? `\n\n**Source:** \`${entry.sourcePath}\``
+                        : '')),
+                sortText: entry.source === 'local'
+                    ? `2_${seq.name}`
+                    : `2z_${seq.name}`
+            }));
+        }
+        return items;
+    }
+    /**
+     * Get JSON variables that can be used for property assignment.
+     * These are variables declared with "var x = run readJson ..."
+     */
+    getJsonVariableCompletions(document, linePrefix) {
+        const items = [];
+        const text = document.getText();
+        const trimmed = linePrefix.trim().toLowerCase();
+        // Only trigger if line starts with a letter (potential variable name) or is empty/whitespace
+        // Don't trigger if it looks like a keyword, method, or other construct
+        if (trimmed && !/^[a-zA-Z_]/.test(trimmed)) {
+            return items;
+        }
+        // Find all JSON variable declarations
+        const jsonVarRegex = /^\s*var\s+([a-zA-Z_][a-zA-Z0-9_]*)\s*=\s*run\s+readJson\s+(.+)$/gm;
+        let match;
+        while ((match = jsonVarRegex.exec(text)) !== null) {
+            const varName = match[1];
+            const filePath = match[2].trim();
+            // Filter by what user has typed (if anything)
+            if (trimmed && !varName.toLowerCase().startsWith(trimmed)) {
+                continue;
+            }
+            items.push(this.createCompletionItem(varName, vscode.CompletionItemKind.Variable, {
+                insertText: varName,
+                detail: 'JSON object',
+                documentation: new vscode.MarkdownString(`**JSON Variable:** \`${varName}\`\n\n` +
+                    `**Source:** \`${filePath}\`\n\n` +
+                    'Update a property:\n```norn\n' +
+                    `${varName}.propertyName = newValue\n` +
+                    `${varName}.nested.path = value\n` +
+                    `${varName}[0].name = value\n` +
+                    '```'),
+                sortText: `0_json_${varName}`
+            }));
+        }
+        return items;
+    }
+    /**
+     * Check if user is typing a variable name for property assignment.
+     * e.g., "config." or "data[0]."
+     */
+    isTypingPropertyAssignment(linePrefix) {
+        // Disabled - user prefers to type properties manually
+        return false;
+    }
+    /**
+     * Get property completions for a JSON variable after typing the dot.
+     */
+    getPropertyAssignmentCompletions(document, linePrefix) {
+        // Disabled - user prefers to type properties manually
+        return [];
+    }
+    isResponseProducingSequenceStepType(type) {
+        return type === 'request' ||
+            type === 'varRequest' ||
+            type === 'namedRequest' ||
+            type === 'varRunSequence' ||
+            type === 'apiRequest';
+    }
+    findResponseCaptureRequestSource(document, position, requestIndex) {
+        if (!Number.isInteger(requestIndex) || requestIndex < 1) {
+            return undefined;
+        }
+        const fullText = document.getText();
+        const sequence = (0, sequenceRunner_1.extractSequences)(fullText).find(seq => position.line > seq.startLine && position.line < seq.endLine);
+        if (!sequence) {
+            return undefined;
+        }
+        const relativeCursorLine = position.line - sequence.startLine - 1;
+        let seenRequests = 0;
+        for (const step of (0, sequenceRunner_1.extractStepsFromSequence)(sequence.content)) {
+            if (step.lineNumber >= relativeCursorLine) {
+                break;
+            }
+            if (!this.isResponseProducingSequenceStepType(step.type)) {
+                continue;
+            }
+            seenRequests++;
+            if (seenRequests !== requestIndex) {
+                continue;
+            }
+            const absoluteLine = sequence.startLine + 1 + step.lineNumber;
+            if (absoluteLine < 0 || absoluteLine >= document.lineCount) {
+                return undefined;
+            }
+            const request = (0, apiResponseIntellisenseCache_1.parseApiResponseRequestLine)(document.lineAt(absoluteLine).text);
+            if (!request) {
+                return undefined;
+            }
+            return { line: absoluteLine, request };
+        }
+        return undefined;
+    }
+    createGenericResponseBodyPropertyHint(requestNum) {
+        return this.createCompletionItem('property', vscode.CompletionItemKind.Field, {
+            insertText: '',
+            detail: 'Body property path',
+            documentation: new vscode.MarkdownString('Navigate into the response body.\n\n' +
+                'Examples:\n' +
+                `- \`$${requestNum}.body.id\` - get the id field\n` +
+                `- \`$${requestNum}.body.user.name\` - nested property\n` +
+                `- \`$${requestNum}.body[0].id\` - array access`)
+        });
+    }
+    getResponseCaptureBodyCompletionContext(linePrefix) {
+        const match = linePrefix.match(/\$(\d+)\.body((?:\.[a-zA-Z_][a-zA-Z0-9_-]*|\[\d+\])*(?:\.)?)$/i);
+        if (!match || !match[2]) {
+            return undefined;
+        }
+        return {
+            requestNum: match[1],
+            bodySuffix: match[2] || ''
+        };
+    }
+    getResponseCaptureHeaderCompletionContext(linePrefix) {
+        const match = linePrefix.match(/\$(\d+)\.headers\.([a-zA-Z_][a-zA-Z0-9_-]*)?$/i);
+        if (!match) {
+            return undefined;
+        }
+        return {
+            requestNum: match[1],
+            partial: match[2] || ''
+        };
+    }
+    getResponseCaptureTopLevelCompletionContext(linePrefix) {
+        const match = linePrefix.match(/\$(\d+)\.([a-zA-Z_][a-zA-Z0-9_]*)?$/);
+        if (!match) {
+            return undefined;
+        }
+        return {
+            requestNum: match[1],
+            partial: match[2] || ''
+        };
+    }
+    /**
+     * Check if user is typing a response capture reference ($N. or $N.property.)
+     * This is used inside sequences to capture response data.
+     */
+    isTypingResponseCapture(linePrefix) {
+        return Boolean(this.getResponseCaptureBodyCompletionContext(linePrefix) ||
+            this.getResponseCaptureHeaderCompletionContext(linePrefix) ||
+            this.getResponseCaptureTopLevelCompletionContext(linePrefix));
+    }
+    /**
+     * Get completions for response capture ($N.property)
+     */
+    getResponseCaptureCompletions(document, position, linePrefix) {
+        const items = [];
+        const bodyContext = this.getResponseCaptureBodyCompletionContext(linePrefix);
+        if (bodyContext) {
+            const requestSource = this.findResponseCaptureRequestSource(document, position, Number(bodyContext.requestNum));
+            const cachedItems = requestSource
+                ? this.getCachedApiBodyPropertyCompletions(document, requestSource.line, requestSource.request, bodyContext.bodySuffix, '')
+                : undefined;
+            if (cachedItems !== undefined) {
+                return cachedItems;
+            }
+            items.push(this.createGenericResponseBodyPropertyHint(bodyContext.requestNum));
+            return items;
+        }
+        const headerContext = this.getResponseCaptureHeaderCompletionContext(linePrefix);
+        if (headerContext) {
+            // Suggest common header names
+            const commonHeaders = [
+                'Content-Type',
+                'Content-Length',
+                'Cache-Control',
+                'Set-Cookie',
+                'Authorization',
+                'X-Request-Id',
+                'X-RateLimit-Remaining',
+                'Location',
+                'ETag',
+            ];
+            for (const header of commonHeaders) {
+                if (!headerContext.partial || header.toLowerCase().startsWith(headerContext.partial.toLowerCase())) {
+                    items.push(this.createCompletionItem(header, vscode.CompletionItemKind.Field, {
+                        insertText: header,
+                        detail: 'Response header',
+                        documentation: new vscode.MarkdownString(`Access the \`${header}\` response header from request $${headerContext.requestNum}.`)
+                    }));
+                }
+            }
+            return items;
+        }
+        const captureMatch = this.getResponseCaptureTopLevelCompletionContext(linePrefix);
+        if (!captureMatch) {
+            return items;
+        }
+        const requestNum = captureMatch.requestNum;
+        const partial = captureMatch.partial;
+        // Top-level response properties
+        const responseProperties = [
+            {
+                name: 'status',
+                detail: 'number',
+                doc: 'HTTP status code (e.g., 200, 404, 500)',
+                example: 'assert $1.status == 200'
+            },
+            {
+                name: 'statusText',
+                detail: 'string',
+                doc: 'HTTP status message (e.g., "OK", "Not Found")',
+                example: 'var message = $1.statusText'
+            },
+            {
+                name: 'headers',
+                detail: 'object',
+                doc: 'Response headers. Use `headers.Name` to access specific header.',
+                example: '$1.headers.Content-Type'
+            },
+            {
+                name: 'duration',
+                detail: 'number',
+                doc: 'Request duration in milliseconds',
+                example: 'assert $1.duration < 1000'
+            },
+            {
+                name: 'body',
+                detail: 'any',
+                doc: 'Response body. Use `body.path` to access nested properties.',
+                example: 'var userId = $1.body.user.id'
+            },
+            {
+                name: 'cookies',
+                detail: 'array',
+                doc: 'Cookies stored in the response session.',
+                example: '$1.cookies'
+            },
+        ];
+        for (const prop of responseProperties) {
+            if (!partial || prop.name.toLowerCase().startsWith(partial.toLowerCase())) {
+                // Sort: commonly used first
+                const sortOrder = ['status', 'body', 'headers', 'statusText', 'duration', 'cookies'];
+                items.push(this.createCompletionItem(prop.name, vscode.CompletionItemKind.Property, {
+                    insertText: prop.name,
+                    detail: prop.detail,
+                    documentation: new vscode.MarkdownString(`**${prop.name}** (\`${prop.detail}\`)\n\n${prop.doc}\n\n**Example:**\n\`\`\`norn\n${prop.example}\n\`\`\``),
+                    sortText: `${sortOrder.indexOf(prop.name)}_${prop.name}`
+                }));
+            }
+        }
+        return items;
+    }
+    /**
+     * Check if user is typing a sequence tag (starts with @ at the beginning of a line)
+     */
+    isTypingSequenceTag(linePrefix) {
+        const trimmed = linePrefix.trim();
+        // Check if the line starts with @ or has @ after other tags
+        // e.g., "@" or "@smo" or "@smoke @"
+        return /^\s*@[a-zA-Z0-9_-]*$/.test(linePrefix) ||
+            /^\s*(?:@[a-zA-Z_][a-zA-Z0-9_-]*(?:\([^)]+\))?\s+)+@[a-zA-Z0-9_-]*$/.test(linePrefix);
+    }
+    /**
+     * Get completion items for sequence tags.
+     * Scans the workspace for existing tags and suggests them.
+     */
+    getSequenceTagCompletions(document, linePrefix) {
+        const items = [];
+        const text = document.getText();
+        // Extract the partial tag being typed (after the last @)
+        const lastAtPos = linePrefix.lastIndexOf('@');
+        const partial = linePrefix.substring(lastAtPos + 1).toLowerCase();
+        // Collect all existing tags from the document
+        const existingTags = new Map(); // name -> values (empty set for simple tags)
+        const tagPattern = /@([a-zA-Z_][a-zA-Z0-9_-]*)(?:\(([^)]+)\))?/g;
+        let match;
+        while ((match = tagPattern.exec(text)) !== null) {
+            const tagName = match[1];
+            const tagValue = match[2];
+            if (!existingTags.has(tagName)) {
+                existingTags.set(tagName, new Set());
+            }
+            if (tagValue) {
+                existingTags.get(tagName).add(tagValue);
+            }
+        }
+        // Also check other .norn files in the workspace
+        for (const otherDoc of vscode.workspace.textDocuments) {
+            if (otherDoc.languageId === 'norn' && otherDoc.uri.toString() !== document.uri.toString()) {
+                const otherText = otherDoc.getText();
+                let otherMatch;
+                const otherPattern = /@([a-zA-Z_][a-zA-Z0-9_-]*)(?:\(([^)]+)\))?/g;
+                while ((otherMatch = otherPattern.exec(otherText)) !== null) {
+                    const tagName = otherMatch[1];
+                    const tagValue = otherMatch[2];
+                    if (!existingTags.has(tagName)) {
+                        existingTags.set(tagName, new Set());
+                    }
+                    if (tagValue) {
+                        existingTags.get(tagName).add(tagValue);
+                    }
+                }
+            }
+        }
+        // Add common/suggested tag names if no tags exist yet
+        const suggestedTags = ['smoke', 'regression', 'integration', 'unit', 'slow', 'fast', 'priority', 'team', 'feature', 'wip', 'skip'];
+        for (const tag of suggestedTags) {
+            if (!existingTags.has(tag)) {
+                existingTags.set(tag, new Set());
+            }
+        }
+        // Generate completion items
+        for (const [tagName, values] of existingTags) {
+            if (!partial || tagName.toLowerCase().startsWith(partial)) {
+                // Simple tag completion
+                items.push(this.createCompletionItem(tagName, vscode.CompletionItemKind.Constant, {
+                    insertText: tagName,
+                    detail: 'Sequence tag',
+                    documentation: values.size > 0
+                        ? new vscode.MarkdownString(`**@${tagName}**\n\nExisting values: ${Array.from(values).map(v => `\`${v}\``).join(', ')}`)
+                        : new vscode.MarkdownString(`**@${tagName}**\n\nSimple tag for filtering sequences.`),
+                    sortText: `0_${tagName}`
+                }));
+                // If this tag has values, also suggest the key-value form
+                for (const value of values) {
+                    const label = `${tagName}(${value})`;
+                    items.push(this.createCompletionItem(label, vscode.CompletionItemKind.Constant, {
+                        insertText: label,
+                        detail: 'Sequence tag with value',
+                        documentation: new vscode.MarkdownString(`**@${tagName}(${value})**\n\nKey-value tag for filtering sequences.`),
+                        sortText: `1_${tagName}_${value}`
+                    }));
+                }
+            }
+        }
+        // Add @data completion for parameterized tests
+        if (!partial || 'data'.startsWith(partial)) {
+            items.push(this.createCompletionItem('data', vscode.CompletionItemKind.Keyword, {
+                insertText: new vscode.SnippetString('data($0)'),
+                detail: 'Parameterized test data',
+                documentation: new vscode.MarkdownString(`**@data(...)**\n\nProvides inline test data for parameterized test sequences.\n\n` +
+                    `Example:\n\`\`\`norn\n@data(1, "Widget")\n@data(2, "Gadget")\ntest sequence ItemTest(id, expectedName)\n    ...\nend sequence\n\`\`\``),
+                sortText: '00_data'
+            }));
+        }
+        // Add @theory completion for external data files
+        if (!partial || 'theory'.startsWith(partial)) {
+            items.push(this.createCompletionItem('theory', vscode.CompletionItemKind.Keyword, {
+                insertText: new vscode.SnippetString('theory("${1:./testdata.json}")'),
+                detail: 'External test data file',
+                documentation: new vscode.MarkdownString(`**@theory("file.json")**\n\nLoads test data from an external JSON file for parameterized test sequences.\n\n` +
+                    `Example:\n\`\`\`norn\n@theory("./items.json")\ntest sequence BulkTest(id, name, price)\n    ...\nend sequence\n\`\`\`\n\n` +
+                    `JSON file format:\n\`\`\`json\n[\n  { "id": 1, "name": "Widget", "price": 9.99 },\n  { "id": 2, "name": "Gadget", "price": 19.99 }\n]\n\`\`\``),
+                sortText: '00_theory'
+            }));
+        }
+        return items;
+    }
+}
+exports.HttpCompletionProvider = HttpCompletionProvider;
+//# sourceMappingURL=completionProvider.js.map