norn-cli 1.3.16 → 1.3.18

package/out/completionProvider.js

@@ -0,0 +1,1886 @@
+"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 = 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");
+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', '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 lineText = document.lineAt(position).text;
+        const linePrefix = lineText.substring(0, position.character);
+        const lineSuffix = lineText.substring(position.character);
+        const trimmedPrefix = linePrefix.trim().toUpperCase();
+        // Handle .nornapi files separately
+        if (document.languageId === 'nornapi') {
+            return this.getNornapiCompletions(document, position, linePrefix, lineSuffix);
+        }
+        // Don't provide completions inside comments
+        // Comments start with # but not #import
+        if (this.isInsideComment(linePrefix)) {
+            return [];
+        }
+        // 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, linePrefix, lineSuffix);
+        }
+        // Check if user is typing a variable reference (after { or {{)
+        if (this.isTypingVariable(linePrefix)) {
+            return this.getVariableCompletions(document, 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);
+        }
+        // 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);
+        }
+        // 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;
+        }
+        // Check if we're after an API request (GET EndpointName, etc.)
+        // Provide header groups and inline headers
+        if (this.isAfterApiRequest(document, position)) {
+            // 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 [];
+        }
+        // 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;
+    }
+    /**
+     * 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;
+        }
+        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;
+    }
+    /**
+     * 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 = (0, environmentProvider_1.getEnvironmentVariables)();
+        // Get sequence-local variables if we're inside a sequence
+        const sequences = (0, sequenceRunner_1.extractSequences)(fullText);
+        const cursorLine = position.line;
+        const containingSequence = sequences.find(seq => cursorLine > seq.startLine && cursorLine < seq.endLine);
+        const localVars = new Set();
+        if (containingSequence) {
+            // Extract local var declarations from the sequence content
+            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]);
+                }
+            }
+            // Add sequence parameters
+            if (containingSequence.parameters) {
+                for (const param of containingSequence.parameters) {
+                    localVars.add(param.name);
+                }
+            }
+        }
+        // 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;
+            const item = new vscode.CompletionItem(name, kind);
+            item.insertText = name;
+            // Show source in detail
+            const sourceLabel = source === 'env' ? 'env' : source === 'local' ? 'local' : 'file';
+            item.detail = value !== '(local)' ? value : undefined;
+            const sourceDesc = source === 'env'
+                ? '**Source:** Environment'
+                : source === 'local'
+                    ? '**Source:** Local sequence variable'
+                    : '**Source:** File';
+            item.documentation = new vscode.MarkdownString(`**Variable:** \`${name}\`\n\n${sourceDesc}`);
+            // Sort: local first, then file, then env
+            item.sortText = source === 'local' ? `0_${name}` : source === 'file' ? `1_${name}` : `2_${name}`;
+            items.push(item);
+        }
+        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();
+        // 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;
+        }
+        return false;
+    }
+    /**
+     * Check if user is typing a property access on a variable: {{varname. OR varname. (for assertions)
+     * Also handles nested access like user.body. or user.headers.
+     */
+    isTypingVariableProperty(linePrefix) {
+        // Match pattern like {{varname. where varname is a valid identifier
+        if (/\{\{[a-zA-Z_][a-zA-Z0-9_]*\.$/.test(linePrefix)) {
+            return true;
+        }
+        // Match nested property like {{varname.body.
+        if (/\{\{[a-zA-Z_][a-zA-Z0-9_]*\.(body|headers)\.$/.test(linePrefix)) {
+            return true;
+        }
+        // Match pattern like assert varname. or varname.body. (for assertions without braces)
+        // Only if preceded by assert, whitespace at line start, or common comparison contexts
+        if (/(?:^|\s|assert\s+)[a-zA-Z_][a-zA-Z0-9_]*\.$/.test(linePrefix)) {
+            return true;
+        }
+        // Match nested property for assertions: user.body. or user.headers.
+        if (/(?:^|\s|assert\s+)[a-zA-Z_][a-zA-Z0-9_]*\.(body|headers)\.$/.test(linePrefix)) {
+            return true;
+        }
+        return false;
+    }
+    /**
+     * 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, linePrefix, lineSuffix) {
+        const fullText = document.getText();
+        // For {{varName.}} style, check for closing braces
+        let needsBraces = false;
+        let closingBraces = '';
+        if (/\{\{/.test(linePrefix)) {
+            needsBraces = true;
+            const closingBracesAhead = lineSuffix.match(/^\}+/);
+            const numClosingBraces = closingBracesAhead ? closingBracesAhead[0].length : 0;
+            const bracesToAdd = Math.max(0, 2 - numClosingBraces);
+            closingBraces = '}'.repeat(bracesToAdd);
+        }
+        // Check for nested property access like user.body. or user.headers.
+        const nestedMatch = linePrefix.match(/(?:\{\{)?([a-zA-Z_][a-zA-Z0-9_]*)\.(body|headers)\.([a-zA-Z_][a-zA-Z0-9_-]*)?$/i);
+        if (nestedMatch) {
+            const varName = nestedMatch[1];
+            const parentProp = nestedMatch[2].toLowerCase();
+            // Verify this variable is a captured response
+            const varRequestMatch = fullText.match(new RegExp(`var\\s+${varName}\\s*=\\s*(GET|POST|PUT|DELETE|PATCH|HEAD|OPTIONS)\\s+`, 'i'));
+            if (varRequestMatch) {
+                if (parentProp === 'headers') {
+                    // Suggest common header names
+                    return this.getCommonHeaderCompletions(closingBraces);
+                }
+                // For body, we can't know the shape - return empty
+                return [];
+            }
+            return [];
+        }
+        // Extract the variable name from {{varname. or just varname.
+        let match = linePrefix.match(/\{\{([a-zA-Z_][a-zA-Z0-9_]*)\.$/);
+        if (!match) {
+            // Try bare variable (for assertions like assert user.body.username)
+            match = linePrefix.match(/(?:^|\s)([a-zA-Z_][a-zA-Z0-9_]*)\.$/);
+        }
+        if (!match) {
+            return [];
+        }
+        const varName = match[1];
+        // Check if this variable was assigned from a request (var x = GET url)
+        const varRequestMatch = fullText.match(new RegExp(`var\\s+${varName}\\s*=\\s*(GET|POST|PUT|DELETE|PATCH|HEAD|OPTIONS)\\s+`, 'i'));
+        if (varRequestMatch) {
+            // Variable is a captured response - suggest response properties
+            return this.getResponsePropertyCompletions(closingBraces, varName);
+        }
+        // Find what this variable was assigned from
+        // Look for "var varName = run SequenceName" pattern
+        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 [];
+        }
+        const sequenceName = varRunMatch[1];
+        // Find the sequence content - first in current file, then in imports
+        let sequenceContent;
+        // Find the sequence in current file first
+        const sequences = (0, sequenceRunner_1.extractSequences)(fullText);
+        const localSequence = sequences.find(s => s.name === sequenceName);
+        if (localSequence) {
+            sequenceContent = localSequence.content;
+        }
+        else {
+            // Search imported files
+            const importedSequence = this.findSequenceInImports(document, sequenceName);
+            if (importedSequence) {
+                sequenceContent = importedSequence.content;
+            }
+        }
+        if (!sequenceContent) {
+            return [];
+        }
+        // Get the return fields from the sequence
+        const returnFields = (0, sequenceRunner_1.extractReturnVariables)(sequenceContent);
+        if (!returnFields || returnFields.length === 0) {
+            return [];
+        }
+        // Create completions for each return field
+        return returnFields.map(field => {
+            // Extract just the field name (last part after dots)
+            const fieldName = field.includes('.') ? field.split('.').pop() : field;
+            const item = new vscode.CompletionItem(fieldName, vscode.CompletionItemKind.Property);
+            item.insertText = fieldName + closingBraces;
+            item.detail = `from ${sequenceName}`;
+            item.documentation = new vscode.MarkdownString(`Return field from sequence \`${sequenceName}\`\n\n**Expression:** \`${field}\``);
+            item.sortText = `0_${fieldName}`;
+            return item;
+        });
+    }
+    /**
+     * Get completions for response properties (used for variables that captured an HTTP response).
+     * Suggests: body, status, statusText, headers, duration, cookies
+     */
+    getResponsePropertyCompletions(closingBraces, varName) {
+        const items = [];
+        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) {
+            const item = new vscode.CompletionItem(prop.name, vscode.CompletionItemKind.Property);
+            item.insertText = prop.name + closingBraces;
+            item.detail = prop.detail;
+            item.documentation = new vscode.MarkdownString(`**${prop.name}**\n\n${prop.doc}\n\n**Usage:** \`{{${varName}.${prop.name}}}\``);
+            item.sortText = `0_${prop.name}`;
+            items.push(item);
+        }
+        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 => {
+            const item = new vscode.CompletionItem(header, vscode.CompletionItemKind.Property);
+            item.insertText = header + closingBraces;
+            item.detail = 'HTTP header';
+            return item;
+        });
+    }
+    /**
+     * Search imported files for a sequence by name.
+     * Returns the sequence if found, or undefined if not.
+     */
+    findSequenceInImports(document, sequenceName) {
+        const importedDefinitions = this.getImportedRunDefinitions(document);
+        const lowerName = sequenceName.toLowerCase();
+        const found = importedDefinitions.sequences.find(entry => entry.sequence.name.toLowerCase() === lowerName);
+        if (!found) {
+            return undefined;
+        }
+        return { name: found.sequence.name, content: found.sequence.content };
+    }
+    /**
+     * 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')) {
+                    continue;
+                }
+                collectFromFile(path.resolve(importDir, nestedImport.path));
+            }
+        };
+        for (const imp of imports) {
+            if (imp.path.endsWith('.nornapi')) {
+                continue;
+            }
+            collectFromFile(path.resolve(documentDir, imp.path));
+        }
+        return { namedRequests, sequences };
+    }
+    /**
+     * Provide completions for .nornapi files
+     */
+    getNornapiCompletions(document, position, linePrefix, lineSuffix) {
+        const trimmed = linePrefix.trim().toLowerCase();
+        // Check if typing a variable reference ({{)
+        if (this.isTypingVariable(linePrefix)) {
+            return this.getVariableCompletions(document, linePrefix, lineSuffix);
+        }
+        // Determine context based on where we are in the file
+        const textBefore = document.getText(new vscode.Range(new vscode.Position(0, 0), position));
+        // Check if we're inside a headers block
+        const lastHeadersStart = textBefore.lastIndexOf('headers ');
+        const lastHeadersEnd = textBefore.lastIndexOf('end headers');
+        const inHeadersBlock = lastHeadersStart > lastHeadersEnd;
+        // Check if we're inside an endpoints block
+        const lastEndpointsStart = textBefore.lastIndexOf('endpoints');
+        const lastEndpointsEnd = textBefore.lastIndexOf('end endpoints');
+        const inEndpointsBlock = lastEndpointsStart > lastEndpointsEnd &&
+            !textBefore.substring(lastEndpointsStart).startsWith('endpoints '); // Not a header block named "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 ') {
+                const endItem = new vscode.CompletionItem('end headers', vscode.CompletionItemKind.Keyword);
+                endItem.detail = 'Close the headers block';
+                endItem.sortText = '0_end';
+                items.push(endItem);
+            }
+            // Suggest common headers
+            for (const header of this.commonHeaders) {
+                if (!trimmed || header.toLowerCase().startsWith(trimmed)) {
+                    const item = new vscode.CompletionItem(header, vscode.CompletionItemKind.Field);
+                    item.insertText = header + ': ';
+                    item.detail = 'HTTP header';
+                    // Trigger IntelliSense again after inserting the header (for Content-Type values, etc.)
+                    item.command = {
+                        command: 'editor.action.triggerSuggest',
+                        title: 'Trigger Suggest'
+                    };
+                    items.push(item);
+                }
+            }
+            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 ') {
+                const endItem = new vscode.CompletionItem('end endpoints', vscode.CompletionItemKind.Keyword);
+                endItem.detail = 'Close the endpoints block';
+                endItem.sortText = '0_end';
+                items.push(endItem);
+            }
+            // Suggest endpoint definition pattern
+            if (!trimmed || /^[a-z]/i.test(trimmed)) {
+                const endpointItem = new vscode.CompletionItem('EndpointName: GET', vscode.CompletionItemKind.Snippet);
+                endpointItem.insertText = new vscode.SnippetString('${1:EndpointName}: ${2|GET,POST,PUT,DELETE,PATCH|} ${3:url}');
+                endpointItem.detail = 'Define an API endpoint';
+                endpointItem.documentation = 'Create a new endpoint definition.\n\nExample: `GetUser: GET /users/{id}`';
+                items.push(endpointItem);
+            }
+            return items;
+        }
+        // At top level - suggest "headers" and "endpoints" keywords
+        if (!trimmed || 'headers'.startsWith(trimmed)) {
+            const headersItem = new vscode.CompletionItem('headers', vscode.CompletionItemKind.Keyword);
+            headersItem.insertText = new vscode.SnippetString('headers ${1:GroupName}\n$0\nend headers');
+            headersItem.detail = 'Define a header group';
+            headersItem.documentation = 'Create a reusable group of headers.\n\nExample:\n```\nheaders Auth\nAuthorization: Bearer {{token}}\nend headers\n```';
+            items.push(headersItem);
+        }
+        if (!trimmed || 'endpoints'.startsWith(trimmed)) {
+            const endpointsItem = new vscode.CompletionItem('endpoints', vscode.CompletionItemKind.Keyword);
+            endpointsItem.insertText = new vscode.SnippetString('endpoints\n${1:EndpointName}: ${2|GET,POST,PUT,DELETE,PATCH|} ${3:url}\nend endpoints');
+            endpointsItem.detail = 'Define API endpoints';
+            endpointsItem.documentation = 'Create a block of endpoint definitions.\n\nExample:\n```\nendpoints\nGetUser: GET /users/{id}\nCreateUser: POST /users\nend endpoints\n```';
+            items.push(endpointsItem);
+        }
+        if (!trimmed || 'swagger'.startsWith(trimmed)) {
+            const swaggerItem = new vscode.CompletionItem('swagger', vscode.CompletionItemKind.Keyword);
+            swaggerItem.insertText = new vscode.SnippetString('swagger "$0"');
+            swaggerItem.detail = 'Import from OpenAPI/Swagger spec';
+            swaggerItem.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.');
+            items.push(swaggerItem);
+        }
+        return items;
+    }
+    /**
+     * Load API definitions (header groups and endpoints) from imported .nornapi files.
+     */
+    getApiDefinitionsFromImports(document) {
+        const fullText = document.getText();
+        const imports = (0, parser_1.extractImports)(fullText);
+        const headerGroups = [];
+        const endpoints = [];
+        if (imports.length === 0) {
+            return { headerGroups, endpoints };
+        }
+        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);
+            }
+            catch {
+                // Ignore import errors
+            }
+        }
+        return { headerGroups, endpoints };
+    }
+    /**
+     * 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')) {
+            const retryItem = new vscode.CompletionItem('retry', vscode.CompletionItemKind.Keyword);
+            retryItem.detail = 'Retry failed requests';
+            retryItem.documentation = 'retry N - Retry the request N times on failure (5xx, 429, network errors)';
+            retryItem.insertText = 'retry ';
+            items.push(retryItem);
+        }
+        // If backoff is not already on the line, suggest it
+        if (!trimmed.includes('backoff')) {
+            const backoffItem = new vscode.CompletionItem('backoff', vscode.CompletionItemKind.Keyword);
+            backoffItem.detail = 'Backoff duration between retries';
+            backoffItem.documentation = 'backoff N ms - Wait N milliseconds between retries (linear: N * attempt)';
+            backoffItem.insertText = 'backoff ';
+            items.push(backoffItem);
+        }
+        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;
+            }
+            const item = new vscode.CompletionItem(endpoint.name, vscode.CompletionItemKind.Function);
+            // Just insert the endpoint name - let user add () and arguments manually
+            item.insertText = endpoint.name;
+            // Show endpoint details
+            const endpointSignature = `${endpoint.method} ${endpoint.path}`;
+            item.detail = endpointSignature;
+            item.documentation = new vscode.MarkdownString(`**${endpoint.name}**\n\n\`${endpointSignature}\`\n\n` +
+                (endpoint.parameters.length > 0
+                    ? `Parameters: ${endpoint.parameters.map(p => `\`{${p}}\``).join(', ')}`
+                    : 'No parameters'));
+            item.sortText = `0_${endpoint.name}`;
+            items.push(item);
+        }
+        return items;
+    }
+    /**
+     * Get header group completions after an API endpoint
+     */
+    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;
+            }
+            const item = new vscode.CompletionItem(hg.name, vscode.CompletionItemKind.Module);
+            item.insertText = hg.name + ' ';
+            // Show headers in the group
+            const headerList = Object.entries(hg.headers)
+                .map(([name, value]) => `  ${name}: ${value}`)
+                .join('\n');
+            item.detail = `Header group (${Object.keys(hg.headers).length} headers)`;
+            item.documentation = new vscode.MarkdownString(`**${hg.name}**\n\nHeaders:\n\`\`\`\n${headerList}\n\`\`\``);
+            item.sortText = `0_${hg.name}`;
+            items.push(item);
+        }
+        return items;
+    }
+    /**
+     * Check if we're on a line after an API request (METHOD EndpointName).
+     * This is used to provide header completions for API endpoint requests.
+     * Allows inline headers and header groups on lines following an API endpoint.
+     */
+    isAfterApiRequest(document, position) {
+        const apiDefs = this.getApiDefinitionsFromImports(document);
+        if (apiDefs.endpoints.length === 0) {
+            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
+            if (!prevLine) {
+                // Empty line means we're past the request block
+                return false;
+            }
+            // 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;
+            }
+            // 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 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;
+            }
+            const item = new vscode.CompletionItem(hg.name, vscode.CompletionItemKind.Module);
+            item.insertText = hg.name;
+            const headerList = Object.entries(hg.headers)
+                .map(([name, value]) => `  ${name}: ${value}`)
+                .join('\n');
+            item.detail = `Header group (${Object.keys(hg.headers).length} headers)`;
+            item.documentation = new vscode.MarkdownString(`**${hg.name}**\n\nHeaders:\n\`\`\`\n${headerList}\n\`\`\``);
+            item.sortText = `0_${hg.name}`;
+            items.push(item);
+        }
+        return items;
+    }
+    getVariableCompletions(document, linePrefix, lineSuffix) {
+        const fullText = document.getText();
+        const fileVariables = (0, parser_1.extractVariables)(fullText);
+        const envVariables = (0, environmentProvider_1.getEnvironmentVariables)();
+        const activeEnv = (0, environmentProvider_1.getActiveEnvironment)();
+        // Merge: env variables first, then file variables (file takes precedence for values)
+        const allVariables = {};
+        // Add environment variables
+        for (const [name, value] of Object.entries(envVariables)) {
+            allVariables[name] = { value, source: 'env' };
+        }
+        // Add/override with file variables
+        for (const [name, value] of Object.entries(fileVariables)) {
+            allVariables[name] = { value, source: 'file' };
+        }
+        if (Object.keys(allVariables).length === 0) {
+            return [];
+        }
+        // Determine context: how many braces are already typed
+        const endsWithDoubleBrace = linePrefix.endsWith('{{');
+        const endsWithSingleBrace = linePrefix.endsWith('{') && !endsWithDoubleBrace;
+        // Check if typing variable name after {{
+        const partialVarMatch = linePrefix.match(/\{\{([a-zA-Z_][a-zA-Z0-9_]*)$/);
+        const partialVarName = partialVarMatch ? partialVarMatch[1] : '';
+        // Check how many closing braces are already ahead (from VS Code auto-close)
+        const closingBracesAhead = lineSuffix.match(/^\}+/);
+        const numClosingBraces = closingBracesAhead ? closingBracesAhead[0].length : 0;
+        // Calculate how many }} we need to add
+        const bracesToAdd = Math.max(0, 2 - numClosingBraces);
+        const closingBraces = '}'.repeat(bracesToAdd);
+        return Object.entries(allVariables).map(([name, { value, source }]) => {
+            // Use different icons for file vs environment variables
+            const kind = source === 'env'
+                ? vscode.CompletionItemKind.Constant // Globe-like icon
+                : vscode.CompletionItemKind.Variable;
+            const item = new vscode.CompletionItem(name, kind);
+            // Determine what to insert based on context
+            if (partialVarName) {
+                // User already typed {{ and partial name, just complete the name + }}
+                item.insertText = name + closingBraces;
+                item.range = new vscode.Range(new vscode.Position(0, linePrefix.length - partialVarName.length), new vscode.Position(0, linePrefix.length));
+            }
+            else if (endsWithDoubleBrace) {
+                // User typed {{, add name + }}
+                item.insertText = name + closingBraces;
+            }
+            else if (endsWithSingleBrace) {
+                // User typed {, add { + name + }}
+                item.insertText = '{' + name + closingBraces;
+            }
+            else {
+                // Fallback: add full {{name}}
+                item.insertText = '{{' + name + closingBraces;
+            }
+            // Show source in detail
+            const sourceLabel = source === 'env'
+                ? `$(globe) env${activeEnv ? `:${activeEnv}` : ''}`
+                : '$(file) file';
+            item.detail = `${value}`;
+            const sourceDesc = source === 'env'
+                ? `**Source:** Environment${activeEnv ? ` (${activeEnv})` : ''}`
+                : '**Source:** File';
+            item.documentation = new vscode.MarkdownString(`**Variable:** \`${name}\`\n\n**Value:** \`${value}\`\n\n${sourceDesc}`);
+            // Sort: file variables first (they override), then env
+            item.sortText = source === 'file' ? `0_${name}` : `1_${name}`;
+            return item;
+        });
+    }
+    // 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 => {
+            const item = new vscode.CompletionItem(method, vscode.CompletionItemKind.Keyword);
+            item.insertText = method;
+            item.documentation = `HTTP ${method} request`;
+            // Sort HTTP methods at the top
+            item.sortText = '0_' + method;
+            // Preselect if user is actively typing this method
+            if (lowerTyped && method.toLowerCase().startsWith(lowerTyped)) {
+                item.preselect = true;
+            }
+            return item;
+        });
+    }
+    getKeywordCompletions() {
+        const items = [];
+        // var keyword
+        const varItem = new vscode.CompletionItem('var', vscode.CompletionItemKind.Keyword);
+        varItem.insertText = 'var ';
+        varItem.documentation = new vscode.MarkdownString('Declare a variable.\n\n`var myVar = someValue`\n\nReference with `{{myVar}}`');
+        varItem.sortText = '1_var';
+        items.push(varItem);
+        // sequence keyword
+        const seqItem = new vscode.CompletionItem('sequence', vscode.CompletionItemKind.Keyword);
+        seqItem.insertText = new vscode.SnippetString('sequence $0\n\nend sequence');
+        seqItem.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```');
+        seqItem.sortText = '1_sequence';
+        items.push(seqItem);
+        // test sequence keyword
+        const testSeqItem = new vscode.CompletionItem('test sequence', vscode.CompletionItemKind.Keyword);
+        testSeqItem.insertText = new vscode.SnippetString('test sequence $0\n\nend sequence');
+        testSeqItem.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' +
+            '```');
+        testSeqItem.sortText = '1_test_sequence';
+        items.push(testSeqItem);
+        // end sequence keyword
+        const endSeqItem = new vscode.CompletionItem('end sequence', vscode.CompletionItemKind.Keyword);
+        endSeqItem.insertText = 'end sequence';
+        endSeqItem.documentation = 'End a sequence block';
+        endSeqItem.sortText = '1_end_sequence';
+        items.push(endSeqItem);
+        // run bash
+        const runBashItem = new vscode.CompletionItem('run bash', vscode.CompletionItemKind.Keyword);
+        runBashItem.insertText = 'run bash ';
+        runBashItem.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.');
+        runBashItem.sortText = '1_run_bash';
+        items.push(runBashItem);
+        // run powershell
+        const runPsItem = new vscode.CompletionItem('run powershell', vscode.CompletionItemKind.Keyword);
+        runPsItem.insertText = 'run powershell ';
+        runPsItem.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.');
+        runPsItem.sortText = '1_run_powershell';
+        items.push(runPsItem);
+        // run js
+        const runJsItem = new vscode.CompletionItem('run js', vscode.CompletionItemKind.Keyword);
+        runJsItem.insertText = 'run js ';
+        runJsItem.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.');
+        runJsItem.sortText = '1_run_js';
+        items.push(runJsItem);
+        // run (plain - for running named requests)
+        const runItem = new vscode.CompletionItem('run', vscode.CompletionItemKind.Keyword);
+        runItem.insertText = 'run ';
+        runItem.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```');
+        runItem.sortText = '1_run';
+        items.push(runItem);
+        // print
+        const printItem = new vscode.CompletionItem('print', vscode.CompletionItemKind.Keyword);
+        printItem.insertText = 'print ';
+        printItem.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.');
+        printItem.sortText = '1_print';
+        items.push(printItem);
+        // assert
+        const assertItem = new vscode.CompletionItem('assert', vscode.CompletionItemKind.Keyword);
+        assertItem.insertText = 'assert ';
+        assertItem.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`');
+        assertItem.sortText = '1_assert';
+        items.push(assertItem);
+        // if statement
+        const ifItem = new vscode.CompletionItem('if', vscode.CompletionItemKind.Keyword);
+        ifItem.documentation = 'Conditional execution based on response values';
+        ifItem.sortText = '1_if';
+        items.push(ifItem);
+        // end if
+        const endIfItem = new vscode.CompletionItem('end if', vscode.CompletionItemKind.Keyword);
+        endIfItem.documentation = 'End an if conditional block';
+        endIfItem.sortText = '1_end_if';
+        items.push(endIfItem);
+        // wait command
+        const waitItem = new vscode.CompletionItem('wait', vscode.CompletionItemKind.Keyword);
+        waitItem.documentation = 'Pause execution for a specified duration (e.g., wait 1s, wait 500ms)';
+        waitItem.sortText = '1_wait';
+        items.push(waitItem);
+        // run readJson - load JSON file into variable
+        const jsonItem = new vscode.CompletionItem('run readJson', vscode.CompletionItemKind.Keyword);
+        jsonItem.insertText = 'run readJson';
+        jsonItem.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]`.');
+        jsonItem.sortText = '1_run_readJson';
+        items.push(jsonItem);
+        // import - import requests and sequences from another file
+        const importItem = new vscode.CompletionItem('import', vscode.CompletionItemKind.Keyword);
+        importItem.insertText = new vscode.SnippetString('import "$0"');
+        importItem.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.');
+        importItem.sortText = '1_import';
+        items.push(importItem);
+        return items;
+    }
+    getHeaderCompletions() {
+        return this.commonHeaders.map(header => {
+            const item = new vscode.CompletionItem(header, vscode.CompletionItemKind.Field);
+            item.insertText = `${header}: `;
+            item.documentation = `HTTP header: ${header}`;
+            // Trigger IntelliSense again after inserting the header (for Content-Type values, etc.)
+            item.command = {
+                command: 'editor.action.triggerSuggest',
+                title: 'Trigger Suggest'
+            };
+            return item;
+        });
+    }
+    getContentTypeCompletions() {
+        return this.contentTypes.map(type => {
+            const item = new vscode.CompletionItem(type, vscode.CompletionItemKind.Value);
+            item.documentation = `Content type: ${type}`;
+            return item;
+        });
+    }
+    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())) {
+                const item = new vscode.CompletionItem(method, vscode.CompletionItemKind.Method);
+                item.insertText = method;
+                item.detail = `Capture ${method} response into variable`;
+                item.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\``);
+                item.sortText = `0_${method}`;
+                items.push(item);
+            }
+        }
+        // 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
+            const runItem = new vscode.CompletionItem('run', vscode.CompletionItemKind.Keyword);
+            runItem.insertText = 'run ';
+            runItem.detail = 'Run a script or named request';
+            runItem.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```');
+            runItem.sortText = '0_run';
+            runItem.command = {
+                command: 'editor.action.triggerSuggest',
+                title: 'Trigger Suggest'
+            };
+            items.push(runItem);
+        }
+        // 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())) {
+            const trueItem = new vscode.CompletionItem('true', vscode.CompletionItemKind.Keyword);
+            trueItem.detail = 'Boolean true';
+            items.push(trueItem);
+        }
+        if (afterEquals === '' || 'false'.startsWith(afterEquals.toLowerCase())) {
+            const falseItem = new vscode.CompletionItem('false', vscode.CompletionItemKind.Keyword);
+            falseItem.detail = 'Boolean false';
+            items.push(falseItem);
+        }
+        if (afterEquals === '' || 'null'.startsWith(afterEquals.toLowerCase())) {
+            const nullItem = new vscode.CompletionItem('null', vscode.CompletionItemKind.Keyword);
+            nullItem.detail = 'Null value';
+            items.push(nullItem);
+        }
+        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)();
+        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 item = new vscode.CompletionItem(name, vscode.CompletionItemKind.Variable);
+            item.detail = value.length > 50 ? value.substring(0, 47) + '...' : value;
+            item.documentation = `Variable: ${name}`;
+            // If the value is JSON, indicate it can be accessed with paths
+            try {
+                const parsed = JSON.parse(value);
+                if (typeof parsed === 'object' && parsed !== null) {
+                    item.documentation = `JSON variable - access properties with ${name}.property`;
+                    item.detail = 'JSON object';
+                }
+            }
+            catch {
+                // Not JSON, use value as detail
+            }
+            items.push(item);
+        }
+        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;
+    }
+    /**
+     * 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) {
+            const runItem = new vscode.CompletionItem('run', vscode.CompletionItemKind.Method);
+            runItem.insertText = 'run ';
+            runItem.documentation = new vscode.MarkdownString('Execute a script or named request\n\n**Options:** `bash`, `powershell`, `js`, `readJson`, or a sequence name');
+            runItem.sortText = '0_run';
+            // Trigger IntelliSense again after inserting 'run '
+            runItem.command = {
+                command: 'editor.action.triggerSuggest',
+                title: 'Trigger Suggest'
+            };
+            items.push(runItem);
+            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}}' },
+        ];
+        for (const st of scriptTypes) {
+            if (!afterRun || st.name.toLowerCase().startsWith(afterRun.toLowerCase())) {
+                const item = new vscode.CompletionItem(st.name, vscode.CompletionItemKind.Method);
+                item.insertText = st.name + ' ';
+                item.documentation = new vscode.MarkdownString(st.doc);
+                item.sortText = `0_${st.name}`;
+                items.push(item);
+            }
+        }
+        // Add named request completions
+        for (const entry of namedRequests) {
+            const req = entry.request;
+            if (afterRun && !req.name.toLowerCase().startsWith(afterRun)) {
+                continue;
+            }
+            const item = new vscode.CompletionItem(req.name, vscode.CompletionItemKind.Function);
+            item.insertText = req.name;
+            // 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)})`
+                : '';
+            if (methodMatch) {
+                item.detail = `${methodMatch[1]} ${methodMatch[2].split('\n')[0]}${sourceSuffix}`;
+            }
+            else if (sourceSuffix) {
+                item.detail = `Named request${sourceSuffix}`;
+            }
+            item.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}\``
+                    : ''));
+            item.sortText = entry.source === 'local'
+                ? `1_${req.name}`
+                : `1z_${req.name}`;
+            items.push(item);
+        }
+        // Add sequence completions
+        for (const entry of sequences) {
+            const seq = entry.sequence;
+            if (afterRun && !seq.name.toLowerCase().startsWith(afterRun)) {
+                continue;
+            }
+            const item = new vscode.CompletionItem(seq.name, vscode.CompletionItemKind.Module);
+            item.insertText = seq.name;
+            const sequenceType = seq.isTest ? 'Test Sequence' : 'Sequence';
+            const sourceSuffix = entry.source === 'imported' && entry.sourcePath
+                ? ` (imported: ${path.basename(entry.sourcePath)})`
+                : '';
+            item.detail = `${sequenceType}${sourceSuffix}`;
+            // Count steps in the sequence for info
+            const stepCount = seq.content.split('\n').filter(l => l.trim() !== '').length;
+            item.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}\``
+                    : ''));
+            item.sortText = entry.source === 'local'
+                ? `2_${seq.name}`
+                : `2z_${seq.name}`;
+            items.push(item);
+        }
+        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;
+            }
+            const item = new vscode.CompletionItem(varName, vscode.CompletionItemKind.Variable);
+            item.insertText = varName;
+            item.detail = 'JSON object';
+            item.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` +
+                '```');
+            item.sortText = `0_json_${varName}`;
+            items.push(item);
+        }
+        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 [];
+    }
+    /**
+     * Check if user is typing a response capture reference ($N. or $N.property.)
+     * This is used inside sequences to capture response data.
+     */
+    isTypingResponseCapture(linePrefix) {
+        // Match patterns like:
+        // $1.  (just typed the dot)
+        // $1.st  (typing a property)
+        // $1.body.  (typed body., waiting for body path)
+        // $1.headers.  (typed headers., waiting for header name)
+        return /\$\d+\.$/.test(linePrefix) || /\$\d+\.[a-zA-Z_][a-zA-Z0-9_]*$/.test(linePrefix);
+    }
+    /**
+     * Get completions for response capture ($N.property)
+     */
+    getResponseCaptureCompletions(document, position, linePrefix) {
+        const items = [];
+        // Extract what's been typed after $N.
+        // Match $N. or $N.partial
+        const captureMatch = linePrefix.match(/\$(\d+)\.([a-zA-Z_][a-zA-Z0-9_]*)?$/);
+        if (!captureMatch) {
+            return items;
+        }
+        const requestNum = captureMatch[1];
+        const partial = captureMatch[2] || '';
+        // Check if we're in a sub-property context like $1.headers. or $1.body.
+        const subPropertyMatch = linePrefix.match(/\$\d+\.(headers|body)\.([a-zA-Z_][a-zA-Z0-9_-]*)?$/i);
+        if (subPropertyMatch) {
+            const parentProp = subPropertyMatch[1].toLowerCase();
+            const subPartial = subPropertyMatch[2] || '';
+            if (parentProp === 'headers') {
+                // 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 (!subPartial || header.toLowerCase().startsWith(subPartial.toLowerCase())) {
+                        const item = new vscode.CompletionItem(header, vscode.CompletionItemKind.Field);
+                        item.insertText = header;
+                        item.detail = 'Response header';
+                        item.documentation = new vscode.MarkdownString(`Access the \`${header}\` response header from request $${requestNum}.`);
+                        items.push(item);
+                    }
+                }
+                return items;
+            }
+            // For body., we can't know the structure without executing, but we can hint
+            if (parentProp === 'body') {
+                const item = new vscode.CompletionItem('property', vscode.CompletionItemKind.Field);
+                item.insertText = '';
+                item.detail = 'Body property path';
+                item.documentation = new vscode.MarkdownString('Navigate into the response body.\n\n' +
+                    'Examples:\n' +
+                    '- `$1.body.id` - get the id field\n' +
+                    '- `$1.body.user.name` - nested property\n' +
+                    '- `$1.body[0].id` - array access');
+                items.push(item);
+                return items;
+            }
+        }
+        // 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'
+            },
+        ];
+        for (const prop of responseProperties) {
+            if (!partial || prop.name.toLowerCase().startsWith(partial.toLowerCase())) {
+                const item = new vscode.CompletionItem(prop.name, vscode.CompletionItemKind.Property);
+                item.insertText = prop.name;
+                item.detail = prop.detail;
+                item.documentation = new vscode.MarkdownString(`**${prop.name}** (\`${prop.detail}\`)\n\n${prop.doc}\n\n**Example:**\n\`\`\`norn\n${prop.example}\n\`\`\``);
+                // Sort: commonly used first
+                const sortOrder = ['status', 'body', 'headers', 'statusText', 'duration'];
+                item.sortText = `${sortOrder.indexOf(prop.name)}_${prop.name}`;
+                items.push(item);
+            }
+        }
+        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
+                const item = new vscode.CompletionItem(tagName, vscode.CompletionItemKind.Constant);
+                item.insertText = tagName;
+                item.detail = 'Sequence tag';
+                if (values.size > 0) {
+                    item.documentation = new vscode.MarkdownString(`**@${tagName}**\n\nExisting values: ${Array.from(values).map(v => `\`${v}\``).join(', ')}`);
+                }
+                else {
+                    item.documentation = new vscode.MarkdownString(`**@${tagName}**\n\nSimple tag for filtering sequences.`);
+                }
+                item.sortText = `0_${tagName}`;
+                items.push(item);
+                // If this tag has values, also suggest the key-value form
+                for (const value of values) {
+                    const kvItem = new vscode.CompletionItem(`${tagName}(${value})`, vscode.CompletionItemKind.Constant);
+                    kvItem.insertText = `${tagName}(${value})`;
+                    kvItem.detail = 'Sequence tag with value';
+                    kvItem.documentation = new vscode.MarkdownString(`**@${tagName}(${value})**\n\nKey-value tag for filtering sequences.`);
+                    kvItem.sortText = `1_${tagName}_${value}`;
+                    items.push(kvItem);
+                }
+            }
+        }
+        // Add @data completion for parameterized tests
+        if (!partial || 'data'.startsWith(partial)) {
+            const dataItem = new vscode.CompletionItem('data', vscode.CompletionItemKind.Keyword);
+            dataItem.insertText = new vscode.SnippetString('data(${1:value1}, ${2:value2})');
+            dataItem.detail = 'Parameterized test data';
+            dataItem.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\`\`\``);
+            dataItem.sortText = '00_data'; // Sort before regular tags
+            items.push(dataItem);
+        }
+        // Add @theory completion for external data files
+        if (!partial || 'theory'.startsWith(partial)) {
+            const theoryItem = new vscode.CompletionItem('theory', vscode.CompletionItemKind.Keyword);
+            theoryItem.insertText = new vscode.SnippetString('theory("${1:./testdata.json}")');
+            theoryItem.detail = 'External test data file';
+            theoryItem.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\`\`\``);
+            theoryItem.sortText = '00_theory'; // Sort before regular tags
+            items.push(theoryItem);
+        }
+        return items;
+    }
+}
+exports.HttpCompletionProvider = HttpCompletionProvider;
+//# sourceMappingURL=completionProvider.js.map