norn-cli 1.6.0 → 1.6.2

package/out/completionProvider.js

@@ -1,2404 +0,0 @@
-"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");
-const swaggerBodyIntellisenseCache_1 = require("./swaggerBodyIntellisenseCache");
-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);
-        }
-        // Swagger-based request body IntelliSense for endpoint POST/PUT/PATCH calls.
-        const requestBodyContext = this.getRequestBodyCompletionContext(document, position);
-        if (requestBodyContext) {
-            if (this.isTypingJsonBodyStart(linePrefix)) {
-                return this.getRequestBodyTemplateCompletions(requestBodyContext, position, lineText);
-            }
-            const inlineBodyCompletions = this.getInlineRequestBodyKeyCompletions(requestBodyContext, document, position, linePrefix);
-            if (inlineBodyCompletions.length > 0) {
-                return inlineBodyCompletions;
-            }
-        }
-        const isAfterApiRequest = this.isAfterApiRequest(document, position);
-        // If a JSON body is being started right below an API request, don't show IntelliSense.
-        // We don't know body shape, and header/group suggestions are noisy in this context.
-        if (isAfterApiRequest && this.isTypingJsonBodyStart(linePrefix)) {
-            return [];
-        }
-        // Check if we're after an API request (GET EndpointName, etc.)
-        // Provide header groups and inline headers
-        if (isAfterApiRequest) {
-            // If typing a header name (no colon yet), provide both header groups and inline headers
-            if (!linePrefix.includes(':')) {
-                const headerGroupCompletions = this.getStandaloneHeaderGroupCompletions(document, linePrefix);
-                const headerCompletions = this.getHeaderCompletions();
-                return [...headerGroupCompletions, ...headerCompletions];
-            }
-            // If line has a colon but not Content-Type (which is handled earlier), return empty
-            return [];
-        }
-        // Check if user might be typing a JSON variable name for property assignment
-        const jsonVarCompletions = this.getJsonVariableCompletions(document, linePrefix);
-        // If we have JSON variable completions, show those (for property assignment)
-        if (jsonVarCompletions.length > 0) {
-            return jsonVarCompletions;
-        }
-        // Show HTTP methods/keywords at line start (or while typing them),
-        // but not after a METHOD ... context where endpoint/header logic applies.
-        if ((position.character === 0 || linePrefix.trim() === '' || this.couldBeMethodOrKeyword(trimmedPrefix)) &&
-            !this.isTypingAfterHttpMethod(linePrefix)) {
-            const typedPrefix = linePrefix.trim().toLowerCase();
-            const methodItems = this.getMethodCompletions(typedPrefix);
-            const keywordItems = this.getKeywordCompletions();
-            if (!typedPrefix) {
-                return [...methodItems, ...keywordItems];
-            }
-            const filteredKeywords = keywordItems.filter(item => item.label.toString().toLowerCase().startsWith(typedPrefix));
-            return [...methodItems, ...filteredKeywords];
-        }
-        return [];
-    }
-    /**
-     * Check if the cursor is inside a comment.
-     * Comments start with # but not #import
-     * This handles both line comments (# at start of line) and inline comments (# after code)
-     */
-    isInsideComment(linePrefix) {
-        const trimmed = linePrefix.trimStart();
-        // Check if line starts with # but not #import
-        if (trimmed.startsWith('#') && !trimmed.toLowerCase().startsWith('#import')) {
-            return true;
-        }
-        // Check for inline comments: find # that's not inside quotes and not part of #import
-        // We need to scan through the line and find if cursor is after an unquoted #
-        let inSingleQuote = false;
-        let inDoubleQuote = false;
-        for (let i = 0; i < linePrefix.length; i++) {
-            const char = linePrefix[i];
-            const prevChar = i > 0 ? linePrefix[i - 1] : '';
-            // Skip escaped quotes
-            if (prevChar === '\\') {
-                continue;
-            }
-            if (char === '"' && !inSingleQuote) {
-                inDoubleQuote = !inDoubleQuote;
-            }
-            else if (char === "'" && !inDoubleQuote) {
-                inSingleQuote = !inSingleQuote;
-            }
-            else if (char === '#' && !inSingleQuote && !inDoubleQuote) {
-                // Found an unquoted #, cursor is in a comment
-                return true;
-            }
-        }
-        return false;
-    }
-    /**
-     * Check if cursor is inside a quoted string
-     */
-    isInsideQuotes(linePrefix) {
-        let inSingleQuote = false;
-        let inDoubleQuote = false;
-        for (let i = 0; i < linePrefix.length; i++) {
-            const char = linePrefix[i];
-            const prevChar = i > 0 ? linePrefix[i - 1] : '';
-            // Skip escaped quotes
-            if (prevChar === '\\') {
-                continue;
-            }
-            if (char === '"' && !inSingleQuote) {
-                inDoubleQuote = !inDoubleQuote;
-            }
-            else if (char === "'" && !inDoubleQuote) {
-                inSingleQuote = !inSingleQuote;
-            }
-        }
-        return inSingleQuote || inDoubleQuote;
-    }
-    /**
-     * Detect the start of a JSON body line (e.g., "{" or "[") under an API request.
-     */
-    isTypingJsonBodyStart(linePrefix) {
-        const trimmed = linePrefix.trimStart();
-        return trimmed.startsWith('{') || trimmed.startsWith('[');
-    }
-    /**
-     * Check if user is in a context where bare variable names should be suggested.
-     * This includes:
-     * - Inside function/endpoint parameters: GetUser(|) or GetUser(a, |)
-     * - After print keyword: print |
-     * - After operators in expressions: print "text" + |
-     * - In assertion expressions: assert | == something
-     *
-     * NOT triggered when:
-     * - Inside quoted strings
-     * - Inside {{ }} (handled by getVariableCompletions)
-     */
-    isTypingBareVariableContext(linePrefix, document, position) {
-        // Don't suggest if inside quotes
-        if (this.isInsideQuotes(linePrefix)) {
-            return false;
-        }
-        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)(document.uri.fsPath);
-        // 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();
-        // JSON body/object start should not trigger variable completions.
-        // Body IntelliSense handles this context separately.
-        if (trimmed === '{' || trimmed === '[') {
-            return false;
-        }
-        // Must have something before the brace (not just starting with {)
-        // e.g., "GET {{" or "Authorization: Bearer {{"
-        // Check for {{ with content before it
-        const doubleOpenMatch = trimmed.match(/\S+.*\{\{([a-zA-Z_][a-zA-Z0-9_]*)?$/);
-        if (doubleOpenMatch) {
-            return true;
-        }
-        // Check for single { at the end with content before it
-        const singleOpenMatch = trimmed.match(/\S+.*\{$/);
-        if (singleOpenMatch) {
-            return true;
-        }
-        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 apiMetadata = this.getApiImportMetadata(document);
-        return {
-            headerGroups: apiMetadata.headerGroups,
-            endpoints: apiMetadata.endpoints
-        };
-    }
-    /**
-     * Load imported .nornapi files with endpoint/header data and swagger URL metadata.
-     */
-    getApiImportMetadata(document) {
-        const fullText = document.getText();
-        const imports = (0, parser_1.extractImports)(fullText);
-        const headerGroups = [];
-        const endpoints = [];
-        const apiFiles = [];
-        if (imports.length === 0) {
-            return { headerGroups, endpoints, apiFiles };
-        }
-        const documentDir = path.dirname(document.uri.fsPath);
-        for (const imp of imports) {
-            // Only process .nornapi files
-            if (!imp.path.endsWith('.nornapi')) {
-                continue;
-            }
-            try {
-                const importPath = path.resolve(documentDir, imp.path);
-                const importedContent = fs.readFileSync(importPath, 'utf8');
-                const apiDef = (0, nornapiParser_1.parseNornApiFile)(importedContent);
-                headerGroups.push(...apiDef.headerGroups);
-                endpoints.push(...apiDef.endpoints);
-                apiFiles.push({
-                    sourcePath: importPath,
-                    headerGroups: apiDef.headerGroups,
-                    endpoints: apiDef.endpoints,
-                    swaggerUrls: this.extractSwaggerUrlsFromNornapi(importedContent)
-                });
-            }
-            catch {
-                // Ignore import errors
-            }
-        }
-        return { headerGroups, endpoints, apiFiles };
-    }
-    extractSwaggerUrlsFromNornapi(content) {
-        const urls = new Set();
-        const lines = content.split('\n');
-        for (const line of lines) {
-            const trimmed = line.trim();
-            if (!trimmed || trimmed.startsWith('#')) {
-                continue;
-            }
-            const quotedMatch = trimmed.match(/^swagger\s+["']([^"']+)["']\s*$/i);
-            if (quotedMatch) {
-                urls.add(quotedMatch[1]);
-                continue;
-            }
-            const unquotedMatch = trimmed.match(/^swagger\s+(https?:\/\/\S+)\s*$/i);
-            if (unquotedMatch) {
-                urls.add(unquotedMatch[1]);
-            }
-        }
-        return Array.from(urls);
-    }
-    getRequestBodyCompletionContext(document, position) {
-        const apiMetadata = this.getApiImportMetadata(document);
-        if (apiMetadata.endpoints.length === 0 || apiMetadata.apiFiles.length === 0) {
-            return undefined;
-        }
-        const endpointSchemaMap = this.getEndpointRequestBodySchemaMap(apiMetadata);
-        if (endpointSchemaMap.size === 0) {
-            return undefined;
-        }
-        const headerGroupNames = new Set(apiMetadata.headerGroups.map(group => group.name));
-        for (let lineNum = position.line; lineNum >= 0 && lineNum >= position.line - 80; lineNum--) {
-            const trimmed = document.lineAt(lineNum).text.trim();
-            if (!trimmed || trimmed.startsWith('#')) {
-                continue;
-            }
-            const requestMatch = trimmed.match(/^(?:var\s+[a-zA-Z_][a-zA-Z0-9_]*\s*=\s*)?(GET|POST|PUT|DELETE|PATCH|HEAD|OPTIONS)\s+([a-zA-Z_][a-zA-Z0-9_]*)(?:\([^)]*\))?(?:\s+.*)?$/i);
-            if (requestMatch) {
-                const method = requestMatch[1].toUpperCase();
-                const endpointName = requestMatch[2];
-                if (!this.isRequestBodyMethod(method)) {
-                    return undefined;
-                }
-                const mapped = endpointSchemaMap.get(endpointName);
-                if (!mapped) {
-                    return undefined;
-                }
-                if (mapped.endpoint.method.toUpperCase() !== method) {
-                    return undefined;
-                }
-                const bodyStartLine = this.findRequestBodyStartLine(document, lineNum, position.line, headerGroupNames);
-                if (bodyStartLine === undefined || position.line < bodyStartLine) {
-                    return undefined;
-                }
-                return {
-                    method,
-                    endpointName,
-                    endpoint: mapped.endpoint,
-                    schema: mapped.schema,
-                    bodyStartLine
-                };
-            }
-            if (lineNum !== position.line && this.isBoundaryCommandLine(trimmed)) {
-                return undefined;
-            }
-        }
-        return undefined;
-    }
-    getEndpointRequestBodySchemaMap(apiMetadata) {
-        const endpointSchemaMap = new Map();
-        for (const apiFile of apiMetadata.apiFiles) {
-            if (apiFile.swaggerUrls.length === 0 || apiFile.endpoints.length === 0) {
-                continue;
-            }
-            const cacheEntries = apiFile.swaggerUrls
-                .map(url => (0, swaggerBodyIntellisenseCache_1.getCachedRequestBodySchemasForUrl)(url))
-                .filter((entry) => !!entry);
-            if (cacheEntries.length === 0) {
-                continue;
-            }
-            for (const endpoint of apiFile.endpoints) {
-                if (!this.isRequestBodyMethod(endpoint.method) || endpointSchemaMap.has(endpoint.name)) {
-                    continue;
-                }
-                const method = endpoint.method.toUpperCase();
-                for (const cacheEntry of cacheEntries) {
-                    const normalizedPath = this.normalizeEndpointPathForSwagger(endpoint.path, cacheEntry.baseUrl);
-                    if (!normalizedPath) {
-                        continue;
-                    }
-                    const matchedSchema = cacheEntry.schemas.find(schema => schema.method.toUpperCase() === method &&
-                        schema.path === normalizedPath);
-                    if (!matchedSchema) {
-                        continue;
-                    }
-                    endpointSchemaMap.set(endpoint.name, {
-                        endpoint,
-                        schema: matchedSchema
-                    });
-                    break;
-                }
-            }
-        }
-        return endpointSchemaMap;
-    }
-    normalizeEndpointPathForSwagger(endpointPath, baseUrl) {
-        const rawPath = endpointPath.trim();
-        if (!rawPath) {
-            return undefined;
-        }
-        const getBasePath = () => {
-            if (!baseUrl) {
-                return '';
-            }
-            try {
-                const parsed = new URL(baseUrl);
-                return parsed.pathname.replace(/\/$/, '');
-            }
-            catch {
-                return '';
-            }
-        };
-        const basePath = getBasePath();
-        const normalizeAndStripBasePath = (candidatePath) => {
-            const withoutQuery = candidatePath.split(/[?#]/)[0];
-            let normalized = withoutQuery.startsWith('/') ? withoutQuery : `/${withoutQuery}`;
-            if (basePath) {
-                if (normalized === basePath) {
-                    return '/';
-                }
-                if (normalized.startsWith(`${basePath}/`)) {
-                    normalized = normalized.slice(basePath.length);
-                }
-            }
-            return normalized || '/';
-        };
-        // Handle variable-prefix paths: {{baseUrl}}/users, {{apiRoot}}/v2/users, etc.
-        const variablePrefixMatch = rawPath.match(/^\{\{[^}]+\}\}(.*)$/);
-        if (variablePrefixMatch) {
-            const suffix = variablePrefixMatch[1] || '';
-            return normalizeAndStripBasePath(suffix || '/');
-        }
-        // Most imported endpoints are generated as full URLs, so strip baseUrl first when possible.
-        if (baseUrl && rawPath.startsWith(baseUrl)) {
-            const stripped = rawPath.slice(baseUrl.length);
-            return normalizeAndStripBasePath(stripped || '/');
-        }
-        if (/^https?:\/\//i.test(rawPath)) {
-            try {
-                const endpointUrl = new URL(rawPath);
-                if (baseUrl) {
-                    try {
-                        const parsedBaseUrl = new URL(baseUrl, endpointUrl.origin);
-                        const basePath = parsedBaseUrl.pathname.replace(/\/$/, '');
-                        // Compare by host to tolerate scheme differences (http vs https).
-                        if (endpointUrl.hostname === parsedBaseUrl.hostname) {
-                            if (basePath && endpointUrl.pathname.startsWith(`${basePath}/`)) {
-                                return endpointUrl.pathname.slice(basePath.length);
-                            }
-                            if (basePath && endpointUrl.pathname === basePath) {
-                                return '/';
-                            }
-                        }
-                    }
-                    catch {
-                        // Ignore malformed base URL values (e.g., templated server URLs)
-                    }
-                }
-                return normalizeAndStripBasePath(endpointUrl.pathname || '/');
-            }
-            catch {
-                return undefined;
-            }
-        }
-        return normalizeAndStripBasePath(rawPath);
-    }
-    findRequestBodyStartLine(document, requestLine, currentLine, headerGroupNames) {
-        for (let lineNum = requestLine + 1; lineNum <= currentLine; lineNum++) {
-            const trimmed = document.lineAt(lineNum).text.trim();
-            if (!trimmed || trimmed.startsWith('#')) {
-                continue;
-            }
-            if (headerGroupNames.has(trimmed)) {
-                continue;
-            }
-            if (this.isInlineHeaderLine(trimmed)) {
-                continue;
-            }
-            return lineNum;
-        }
-        return undefined;
-    }
-    isInlineHeaderLine(trimmedLine) {
-        return /^[A-Za-z][A-Za-z0-9-]*:\s*.+$/.test(trimmedLine);
-    }
-    isBoundaryCommandLine(trimmedLine) {
-        return /^(###|\[|(?:test\s+)?sequence\b|end\s+sequence\b|end\s+if\b|endif\b|var\s+|run\s+|print\s+|assert\s+|if\s+|wait\s+|import\s+|return\s+|swagger\b|(GET|POST|PUT|DELETE|PATCH|HEAD|OPTIONS)\s+)/i.test(trimmedLine);
-    }
-    isRequestBodyMethod(method) {
-        return method === 'POST' || method === 'PUT' || method === 'PATCH';
-    }
-    getRequestBodyTemplateCompletions(context, position, lineText) {
-        const templateValue = this.buildTemplateValueFromSchema(context.schema.schema);
-        const rawTemplate = JSON.stringify(templateValue, null, 4);
-        if (!rawTemplate) {
-            return [];
-        }
-        const indentation = lineText.match(/^\s*/)[0];
-        const indentedTemplate = rawTemplate
-            .split('\n')
-            .map(line => indentation + line)
-            .join('\n');
-        const replaceRange = new vscode.Range(new vscode.Position(position.line, 0), new vscode.Position(position.line, lineText.length));
-        const item = new vscode.CompletionItem('Insert request body template', vscode.CompletionItemKind.Snippet);
-        item.insertText = indentedTemplate;
-        item.range = replaceRange;
-        const triggerChar = lineText.trimStart().startsWith('[') ? '[' : '{';
-        item.filterText = triggerChar;
-        item.preselect = true;
-        item.detail = `${context.method} ${context.endpointName}`;
-        item.documentation = new vscode.MarkdownString(`Insert a request body skeleton for \`${context.endpointName}\` from cached Swagger schema.\n\n` +
-            'Template includes required fields only.');
-        item.sortText = '0_request_body_template';
-        return [item];
-    }
-    buildTemplateValueFromSchema(schema) {
-        const normalizedSchema = this.normalizeSchemaForCompletions(schema);
-        const value = this.buildDefaultSchemaValue(normalizedSchema, true);
-        return value === undefined ? {} : value;
-    }
-    buildDefaultSchemaValue(schema, requiredOnly) {
-        const normalizedSchema = this.normalizeSchemaForCompletions(schema);
-        if (!normalizedSchema || typeof normalizedSchema !== 'object') {
-            return null;
-        }
-        if (normalizedSchema.default !== undefined) {
-            return normalizedSchema.default;
-        }
-        if (Array.isArray(normalizedSchema.enum) && normalizedSchema.enum.length > 0) {
-            return normalizedSchema.enum[0];
-        }
-        if (normalizedSchema.type === 'object' || normalizedSchema.properties) {
-            const properties = normalizedSchema.properties;
-            if (!properties || Object.keys(properties).length === 0) {
-                return {};
-            }
-            const required = Array.isArray(normalizedSchema.required)
-                ? normalizedSchema.required.filter((name) => typeof name === 'string')
-                : [];
-            const keys = requiredOnly
-                ? (required.length > 0 ? required : Object.keys(properties))
-                : Object.keys(properties);
-            const result = {};
-            for (const key of keys) {
-                result[key] = this.buildDefaultSchemaValue(properties[key], requiredOnly);
-            }
-            return result;
-        }
-        if (normalizedSchema.type === 'array' || normalizedSchema.items) {
-            return [];
-        }
-        switch (normalizedSchema.type) {
-            case 'number':
-            case 'integer':
-                return 0;
-            case 'boolean':
-                return false;
-            case 'string':
-                return '';
-            case 'null':
-                return null;
-            default:
-                return null;
-        }
-    }
-    getInlineRequestBodyKeyCompletions(context, document, position, linePrefix) {
-        if (!this.isTypingJsonObjectKey(linePrefix)) {
-            return [];
-        }
-        const bodyLinesBeforeCursor = [];
-        for (let lineNum = context.bodyStartLine; lineNum < position.line; lineNum++) {
-            bodyLinesBeforeCursor.push(document.lineAt(lineNum).text);
-        }
-        const jsonContext = this.parseJsonObjectContext(bodyLinesBeforeCursor);
-        const schemaNode = this.getSchemaNodeForPath(context.schema.schema, jsonContext.path);
-        const normalizedSchema = this.normalizeSchemaForCompletions(schemaNode);
-        const properties = normalizedSchema?.properties;
-        if (!properties || Object.keys(properties).length === 0) {
-            return [];
-        }
-        const required = new Set(Array.isArray(normalizedSchema.required)
-            ? normalizedSchema.required.filter((name) => typeof name === 'string')
-            : []);
-        const replaceTokenMatch = linePrefix.match(/"?[a-zA-Z0-9_-]*$/);
-        const replaceToken = replaceTokenMatch ? replaceTokenMatch[0] : '';
-        const partialMatch = linePrefix.match(/"?([a-zA-Z_][a-zA-Z0-9_-]*)?$/);
-        const partial = partialMatch?.[1]?.toLowerCase() || '';
-        const replaceStart = Math.max(0, position.character - replaceToken.length);
-        const replaceRange = new vscode.Range(new vscode.Position(position.line, replaceStart), position);
-        const items = [];
-        for (const [propertyName, propertySchema] of Object.entries(properties)) {
-            if (jsonContext.existingKeys.has(propertyName)) {
-                continue;
-            }
-            if (partial && !propertyName.toLowerCase().startsWith(partial)) {
-                continue;
-            }
-            const item = new vscode.CompletionItem(propertyName, vscode.CompletionItemKind.Property);
-            item.range = replaceRange;
-            item.insertText = `"${propertyName}": `;
-            item.detail = required.has(propertyName)
-                ? `${this.getSchemaTypeDescription(propertySchema)} (required)`
-                : this.getSchemaTypeDescription(propertySchema);
-            item.documentation = new vscode.MarkdownString(`Schema property for \`${context.endpointName}\` request body.`);
-            item.sortText = required.has(propertyName)
-                ? `0_${propertyName}`
-                : `1_${propertyName}`;
-            items.push(item);
-        }
-        return items;
-    }
-    isTypingJsonObjectKey(linePrefix) {
-        const trimmed = linePrefix.trim();
-        if (trimmed.startsWith('{') || trimmed.startsWith('[') || trimmed.startsWith('}') || trimmed.startsWith(']')) {
-            return false;
-        }
-        if (trimmed.includes(':') || trimmed.includes(',')) {
-            return false;
-        }
-        if (trimmed === '' || trimmed === '"') {
-            return true;
-        }
-        return /^"?[a-zA-Z_][a-zA-Z0-9_-]*$/.test(trimmed);
-    }
-    parseJsonObjectContext(lines) {
-        const pathStack = [];
-        const keysByPath = new Map();
-        const getPathKey = () => pathStack.join('.');
-        const ensureKeySet = (pathKey) => {
-            if (!keysByPath.has(pathKey)) {
-                keysByPath.set(pathKey, new Set());
-            }
-            return keysByPath.get(pathKey);
-        };
-        for (const line of lines) {
-            const trimmed = line.trim();
-            if (!trimmed || trimmed.startsWith('#')) {
-                continue;
-            }
-            const closingMatch = trimmed.match(/^[}\]]+/);
-            if (closingMatch) {
-                for (const _ of closingMatch[0]) {
-                    if (pathStack.length > 0) {
-                        pathStack.pop();
-                    }
-                }
-            }
-            const currentPath = getPathKey();
-            const addExistingKey = (key) => {
-                ensureKeySet(currentPath).add(key);
-            };
-            const objectStartMatch = trimmed.match(/^"([^"]+)"\s*:\s*\{\s*,?\s*$/);
-            if (objectStartMatch) {
-                addExistingKey(objectStartMatch[1]);
-                pathStack.push(objectStartMatch[1]);
-                continue;
-            }
-            const arrayStartMatch = trimmed.match(/^"([^"]+)"\s*:\s*\[\s*,?\s*$/);
-            if (arrayStartMatch) {
-                addExistingKey(arrayStartMatch[1]);
-                pathStack.push(arrayStartMatch[1]);
-                continue;
-            }
-            const propertyMatch = trimmed.match(/^"([^"]+)"\s*:/);
-            if (propertyMatch) {
-                addExistingKey(propertyMatch[1]);
-            }
-        }
-        const finalPath = getPathKey();
-        return {
-            path: [...pathStack],
-            existingKeys: new Set(keysByPath.get(finalPath) || [])
-        };
-    }
-    getSchemaNodeForPath(schema, pathSegments) {
-        let currentSchema = this.normalizeSchemaForCompletions(schema);
-        for (const segment of pathSegments) {
-            currentSchema = this.normalizeSchemaForCompletions(currentSchema);
-            if (!currentSchema || typeof currentSchema !== 'object') {
-                return undefined;
-            }
-            const properties = currentSchema.properties;
-            if (!properties || !(segment in properties)) {
-                return undefined;
-            }
-            const propertySchema = this.normalizeSchemaForCompletions(properties[segment]);
-            if (propertySchema?.type === 'array' && propertySchema.items) {
-                currentSchema = this.normalizeSchemaForCompletions(propertySchema.items);
-            }
-            else {
-                currentSchema = propertySchema;
-            }
-        }
-        return this.normalizeSchemaForCompletions(currentSchema);
-    }
-    normalizeSchemaForCompletions(schema) {
-        if (!schema || typeof schema !== 'object') {
-            return schema;
-        }
-        if (Array.isArray(schema.allOf) && schema.allOf.length > 0) {
-            const merged = { ...schema };
-            delete merged.allOf;
-            for (const part of schema.allOf) {
-                const normalizedPart = this.normalizeSchemaForCompletions(part);
-                if (!normalizedPart || typeof normalizedPart !== 'object') {
-                    continue;
-                }
-                if (!merged.type && normalizedPart.type) {
-                    merged.type = normalizedPart.type;
-                }
-                if (normalizedPart.properties && typeof normalizedPart.properties === 'object') {
-                    merged.properties = {
-                        ...(merged.properties || {}),
-                        ...normalizedPart.properties
-                    };
-                }
-                if (normalizedPart.items && !merged.items) {
-                    merged.items = normalizedPart.items;
-                }
-                if (Array.isArray(normalizedPart.required)) {
-                    const existing = Array.isArray(merged.required) ? merged.required : [];
-                    merged.required = Array.from(new Set([...existing, ...normalizedPart.required]));
-                }
-            }
-            return merged;
-        }
-        if (Array.isArray(schema.oneOf) && schema.oneOf.length > 0) {
-            return this.normalizeSchemaForCompletions(schema.oneOf[0]);
-        }
-        if (Array.isArray(schema.anyOf) && schema.anyOf.length > 0) {
-            return this.normalizeSchemaForCompletions(schema.anyOf[0]);
-        }
-        return schema;
-    }
-    getSchemaTypeDescription(schema) {
-        const normalizedSchema = this.normalizeSchemaForCompletions(schema);
-        if (!normalizedSchema || typeof normalizedSchema !== 'object') {
-            return 'value';
-        }
-        if (Array.isArray(normalizedSchema.enum) && normalizedSchema.enum.length > 0) {
-            const enumPreview = normalizedSchema.enum
-                .slice(0, 3)
-                .map((value) => JSON.stringify(value))
-                .join(', ');
-            return normalizedSchema.enum.length > 3
-                ? `enum (${enumPreview}, ...)`
-                : `enum (${enumPreview})`;
-        }
-        if (typeof normalizedSchema.type === 'string') {
-            return normalizedSchema.type;
-        }
-        if (normalizedSchema.properties) {
-            return 'object';
-        }
-        if (normalizedSchema.items) {
-            return 'array';
-        }
-        return 'value';
-    }
-    /**
-     * Check if user is typing after an HTTP method (e.g., "GET " or "POST " or "var x = GET ")
-     * Returns false if inside open parentheses (user is typing parameters)
-     */
-    isTypingAfterHttpMethod(linePrefix) {
-        // Don't match if we're inside open parentheses (typing parameters)
-        const openParens = (linePrefix.match(/\(/g) || []).length;
-        const closeParens = (linePrefix.match(/\)/g) || []).length;
-        if (openParens > closeParens) {
-            return false;
-        }
-        // Match "METHOD " or "METHOD partial" (preserve trailing spaces)
-        let match = linePrefix.match(/^\s*(GET|POST|PUT|DELETE|PATCH|HEAD|OPTIONS)\s+.*$/i);
-        if (match) {
-            return true;
-        }
-        // Also match "var x = METHOD " pattern
-        match = linePrefix.match(/^\s*var\s+[a-zA-Z_][a-zA-Z0-9_]*\s*=\s*(GET|POST|PUT|DELETE|PATCH|HEAD|OPTIONS)\s+.*$/i);
-        return !!match;
-    }
-    /**
-     * Check if user is typing after an API endpoint (for header group suggestions)
-     * e.g., "GET GetUser("1") " or "GET GetAllUsers " or "var x = GET GetUser(1) "
-     */
-    isTypingAfterApiEndpoint(linePrefix, document) {
-        // Match: METHOD EndpointName or METHOD EndpointName(params) followed by space
-        // Also match: var x = METHOD EndpointName(params) followed by space
-        let match = linePrefix.match(/^\s*(GET|POST|PUT|DELETE|PATCH|HEAD|OPTIONS)\s+([a-zA-Z_][a-zA-Z0-9_]*)(?:\([^)]*\))?\s+.*$/i);
-        if (!match) {
-            // Try var x = METHOD EndpointName(params) pattern
-            match = linePrefix.match(/^\s*var\s+[a-zA-Z_][a-zA-Z0-9_]*\s*=\s*(GET|POST|PUT|DELETE|PATCH|HEAD|OPTIONS)\s+([a-zA-Z_][a-zA-Z0-9_]*)(?:\([^)]*\))?\s+.*$/i);
-        }
-        if (!match) {
-            return false;
-        }
-        const potentialEndpointName = match[2];
-        // Check if this is actually an endpoint from .nornapi imports
-        const apiDefs = this.getApiDefinitionsFromImports(document);
-        return apiDefs.endpoints.some(ep => ep.name === potentialEndpointName);
-    }
-    /**
-     * Check if user is typing after a URL in a var request line
-     * e.g., "var result = GET "https://..." " or "var data = GET https://api.com "
-     */
-    isTypingAfterRequestUrl(linePrefix) {
-        const trimmed = linePrefix.trim();
-        // Match: var name = METHOD "url" (quoted URL with everything after closing quote)
-        // or: var name = METHOD url (unquoted URL ending in space)
-        const quotedMatch = trimmed.match(/^var\s+[a-zA-Z_][a-zA-Z0-9_]*\s*=\s*(GET|POST|PUT|DELETE|PATCH|HEAD|OPTIONS)\s+"[^"]+"\s+/i);
-        if (quotedMatch) {
-            return true;
-        }
-        // Also match unquoted URLs: var x = GET https://url space
-        const unquotedMatch = trimmed.match(/^var\s+[a-zA-Z_][a-zA-Z0-9_]*\s*=\s*(GET|POST|PUT|DELETE|PATCH|HEAD|OPTIONS)\s+https?:\/\/\S+\s+/i);
-        if (unquotedMatch) {
-            return true;
-        }
-        return false;
-    }
-    /**
-     * Get retry/backoff completions after a request URL
-     */
-    getRetryBackoffCompletions(linePrefix) {
-        const items = [];
-        const trimmed = linePrefix.trim().toLowerCase();
-        // If retry is not already on the line, suggest it
-        if (!trimmed.includes('retry')) {
-            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 HTTP request.
-     * Supports:
-     * - METHOD EndpointName / METHOD URL
-     * - var x = METHOD EndpointName / URL
-     * Allows inline headers and header groups on following lines.
-     */
-    isAfterApiRequest(document, position) {
-        const apiDefs = this.getApiDefinitionsFromImports(document);
-        // Look at previous lines to see if we're after a request block start.
-        for (let lineNum = position.line - 1; lineNum >= 0 && lineNum >= position.line - 10; lineNum--) {
-            const prevLine = document.lineAt(lineNum).text.trim();
-            // Skip empty lines
-            if (!prevLine) {
-                // Empty line means we're past the request block
-                return false;
-            }
-            // Skip comment lines
-            if (prevLine.startsWith('#')) {
-                continue;
-            }
-            // Skip header group names on their own line
-            if (apiDefs.headerGroups.some(hg => hg.name === prevLine)) {
-                continue;
-            }
-            // Skip inline headers (lines with HeaderName: value pattern)
-            if (/^[A-Za-z][A-Za-z0-9-]*:\s*.+$/.test(prevLine)) {
-                continue;
-            }
-            // Request start: METHOD ...
-            if (/^(GET|POST|PUT|DELETE|PATCH|HEAD|OPTIONS)\s+.+$/i.test(prevLine)) {
-                return true;
-            }
-            // Request start: var x = METHOD ...
-            if (/^var\s+[a-zA-Z_][a-zA-Z0-9_]*\s*=\s*(GET|POST|PUT|DELETE|PATCH|HEAD|OPTIONS)\s+.+$/i.test(prevLine)) {
-                return true;
-            }
-            // If we hit another kind of line that's not recognized, stop
-            break;
-        }
-        return false;
-    }
-    /**
-     * Check if user might be typing a header group name on its own line
-     * This happens after an API request when header groups are on separate lines:
-     *   GET GetAllUsers
-     *   Json
-     *   Auth
-     */
-    isTypingStandaloneHeaderGroup(linePrefix, document, position) {
-        const trimmed = linePrefix.trim();
-        // Must be a simple identifier (no spaces, colons, or special chars except what's being typed)
-        if (trimmed.includes(':') || trimmed.includes(' ') || trimmed.includes('/')) {
-            return false;
-        }
-        // Check if there are any .nornapi imports with header groups
-        const apiDefs = this.getApiDefinitionsFromImports(document);
-        if (apiDefs.headerGroups.length === 0) {
-            return false;
-        }
-        // Check if any header group name starts with what's typed
-        if (trimmed && !apiDefs.headerGroups.some(hg => hg.name.toLowerCase().startsWith(trimmed.toLowerCase()))) {
-            return false;
-        }
-        // Look at previous lines to see if we're after an API request
-        for (let lineNum = position.line - 1; lineNum >= 0 && lineNum >= position.line - 10; lineNum--) {
-            const prevLine = document.lineAt(lineNum).text.trim();
-            // Skip empty lines and header group names
-            if (!prevLine || apiDefs.headerGroups.some(hg => hg.name === prevLine)) {
-                continue;
-            }
-            // Check if this line is an API request (METHOD EndpointName)
-            const match = prevLine.match(/^(GET|POST|PUT|DELETE|PATCH|HEAD|OPTIONS)\s+([a-zA-Z_][a-zA-Z0-9_]*)(?:\([^)]*\))?/i);
-            if (match) {
-                const endpointName = match[2];
-                if (apiDefs.endpoints.some(ep => ep.name === endpointName)) {
-                    return true;
-                }
-            }
-            // If we hit another kind of line (not empty, not header group, not API request), stop
-            break;
-        }
-        return false;
-    }
-    /**
-     * Get header group completions for a standalone line (after an API request)
-     */
-    getStandaloneHeaderGroupCompletions(document, linePrefix) {
-        const apiDefs = this.getApiDefinitionsFromImports(document);
-        const trimmed = linePrefix.trim();
-        const items = [];
-        for (const hg of apiDefs.headerGroups) {
-            if (trimmed && !hg.name.toLowerCase().startsWith(trimmed.toLowerCase())) {
-                continue;
-            }
-            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)(document.uri.fsPath);
-        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)(document.uri.fsPath);
-        const allVariables = { ...envVariables, ...fileVariables };
-        const items = [];
-        const lowerPrefix = prefix.toLowerCase();
-        for (const [name, value] of Object.entries(allVariables)) {
-            // Filter by prefix if user has typed something
-            if (lowerPrefix && !name.toLowerCase().startsWith(lowerPrefix)) {
-                continue;
-            }
-            const 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