norn-cli 1.3.17 → 1.3.19

package/out/parser.js

@@ -0,0 +1,725 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractRetryOptions = extractRetryOptions;
+exports.extractNamedRequests = extractNamedRequests;
+exports.getNamedRequest = getNamedRequest;
+exports.extractVariables = extractVariables;
+exports.extractFileLevelVariables = extractFileLevelVariables;
+exports.substituteVariables = substituteVariables;
+exports.parserHttpRequest = parserHttpRequest;
+exports.getRequestBlockAtLine = getRequestBlockAtLine;
+exports.extractImports = extractImports;
+exports.resolveImports = resolveImports;
+const nornapiParser_1 = require("./nornapiParser");
+/**
+ * Strip inline comment from a line.
+ * Finds # that is not inside quotes and removes everything after it.
+ */
+function stripInlineComment(line) {
+    let inSingleQuote = false;
+    let inDoubleQuote = false;
+    for (let i = 0; i < line.length; i++) {
+        const char = line[i];
+        const prevChar = i > 0 ? line[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 #, strip from here
+            return line.substring(0, i).trimEnd();
+        }
+    }
+    return line;
+}
+/**
+ * Extract retry and backoff options from a request line.
+ * Syntax: GET "URL" retry 3 backoff 500 ms
+ * Returns the cleaned line (without retry/backoff) and the parsed options.
+ */
+function extractRetryOptions(line) {
+    let cleanedLine = line;
+    let retryCount;
+    let backoffMs;
+    // Extract retry count: "retry 3" or "retry 3 "
+    const retryMatch = line.match(/\bretry\s+(\d+)\b/i);
+    if (retryMatch) {
+        retryCount = parseInt(retryMatch[1], 10);
+        cleanedLine = cleanedLine.replace(retryMatch[0], '').trim();
+    }
+    // Extract backoff: "backoff 500 ms" or "backoff 2s" or "backoff 1000"
+    const backoffMatch = line.match(/\bbackoff\s+(\d+(?:\.\d+)?)\s*(s|ms|seconds?|milliseconds?)?\b/i);
+    if (backoffMatch) {
+        const value = parseFloat(backoffMatch[1]);
+        const unit = (backoffMatch[2] || 'ms').toLowerCase();
+        if (unit === 's' || unit.startsWith('second')) {
+            backoffMs = value * 1000;
+        }
+        else {
+            backoffMs = value;
+        }
+        cleanedLine = cleanedLine.replace(backoffMatch[0], '').trim();
+    }
+    // Default backoff if retry specified but not backoff
+    if (retryCount !== undefined && backoffMs === undefined) {
+        backoffMs = 1000; // Default 1 second
+    }
+    return { cleanedLine, retryCount, backoffMs };
+}
+/**
+ * Extracts all named requests from the document.
+ * Named requests are declared as:
+ * [RequestName]  (no spaces allowed)
+ * or legacy: [Name: RequestName]
+ * HTTP_METHOD URL
+ * ...
+ */
+function extractNamedRequests(text) {
+    const lines = text.split('\n');
+    const namedRequests = [];
+    // Match [SomeName] or [Name: SomeName] - name must not contain spaces
+    const nameRegex = /^\[(?:Name:\s*)?([a-zA-Z_][a-zA-Z0-9_-]*)\]$/;
+    const methodRegex = /^(GET|POST|PUT|DELETE|PATCH|HEAD|OPTIONS)\s+/i;
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i].trim();
+        const nameMatch = line.match(nameRegex);
+        if (nameMatch) {
+            const name = nameMatch[1].trim();
+            const contentStartLine = i + 1;
+            // Find the end of this request (next [Name], sequence, ###, or end of file)
+            let endLine = lines.length - 1;
+            for (let j = contentStartLine; j < lines.length; j++) {
+                const scanLine = lines[j].trim();
+                if (scanLine.match(/^\[/) ||
+                    scanLine.match(/^sequence\s+/) ||
+                    scanLine.startsWith('###')) {
+                    endLine = j - 1;
+                    break;
+                }
+            }
+            // Trim trailing empty lines
+            while (endLine > contentStartLine && lines[endLine].trim() === '') {
+                endLine--;
+            }
+            const content = lines.slice(contentStartLine, endLine + 1).join('\n');
+            // Only add if there's actual content with an HTTP method
+            if (content.split('\n').some(l => methodRegex.test(l.trim()))) {
+                namedRequests.push({
+                    name,
+                    content,
+                    startLine: i,
+                    endLine
+                });
+            }
+            // Skip to end of this request
+            i = endLine;
+        }
+    }
+    return namedRequests;
+}
+/**
+ * Gets a named request by its name
+ */
+function getNamedRequest(text, name) {
+    const requests = extractNamedRequests(text);
+    return requests.find(r => r.name === name ||
+        r.name.toLowerCase() === name.toLowerCase());
+}
+/**
+ * Patterns for runtime-computed variable values that should not be treated as static vars.
+ */
+const RUNTIME_VARIABLE_VALUE_PATTERNS = [
+    /^run\s+/i, // var x = run ... (scripts/sequences)
+    /^\$\d+/, // var x = $1... (response captures)
+    /^(GET|POST|PUT|DELETE|PATCH|HEAD|OPTIONS)\s+/i // var x = METHOD url (request captures)
+];
+function isRuntimeComputedVariableValue(value) {
+    return RUNTIME_VARIABLE_VALUE_PATTERNS.some(pattern => pattern.test(value));
+}
+function isSequenceStartDeclaration(line) {
+    return /^(?:test\s+)?sequence\s+[a-zA-Z_][a-zA-Z0-9_-]*(?:\s*\([^)]*\))?\s*$/i.test(line);
+}
+function isSequenceEndDeclaration(line) {
+    return /^end\s+sequence\s*$/i.test(line);
+}
+/**
+ * Extracts all STATIC variables from the document.
+ * Variables are declared as: var variableName = value
+ *
+ * Does NOT extract runtime-computed values:
+ * - var x = run ... (script commands)
+ * - var x = $1... (response captures)
+ * - var x = GET/POST/... url (request captures)
+ */
+function extractVariables(text) {
+    const variables = {};
+    // Allow optional leading whitespace for indented variables (inside sequences)
+    const variableRegex = /^\s*var\s+([a-zA-Z_][a-zA-Z0-9_]*)\s*=\s*(.+)$/gm;
+    let match;
+    while ((match = variableRegex.exec(text)) !== null) {
+        let value = match[2].trim();
+        // Skip runtime-computed values
+        const isRuntimeValue = isRuntimeComputedVariableValue(value);
+        if (isRuntimeValue) {
+            continue;
+        }
+        // Strip quotes from string literals
+        if ((value.startsWith('"') && value.endsWith('"')) ||
+            (value.startsWith("'") && value.endsWith("'"))) {
+            value = value.slice(1, -1);
+        }
+        variables[match[1]] = value;
+    }
+    return variables;
+}
+/**
+ * Extracts only file-level variables (outside sequences).
+ * Used for diagnostics to understand variable scope.
+ */
+function extractFileLevelVariables(text) {
+    const variables = {};
+    const lines = text.split('\n');
+    const variableRegex = /^\s*var\s+([a-zA-Z_][a-zA-Z0-9_]*)\s*=\s*(.+)$/;
+    // Use depth so malformed files don't accidentally leak inner vars to file scope.
+    let sequenceDepth = 0;
+    for (const line of lines) {
+        const trimmed = line.trim();
+        // Track sequence boundaries
+        if (isSequenceStartDeclaration(trimmed)) {
+            sequenceDepth++;
+            continue;
+        }
+        if (isSequenceEndDeclaration(trimmed)) {
+            sequenceDepth = Math.max(0, sequenceDepth - 1);
+            continue;
+        }
+        // Only extract variables outside sequences
+        if (sequenceDepth === 0) {
+            const match = line.match(variableRegex);
+            if (match) {
+                let value = match[2].trim();
+                // Skip runtime-computed values
+                if (isRuntimeComputedVariableValue(value)) {
+                    continue;
+                }
+                // Strip quotes from string literals
+                if ((value.startsWith('"') && value.endsWith('"')) ||
+                    (value.startsWith("'") && value.endsWith("'"))) {
+                    value = value.slice(1, -1);
+                }
+                variables[match[1]] = value;
+            }
+        }
+    }
+    return variables;
+}
+/**
+ * Gets a value from an object using a dot-notation path.
+ * Supports array indexing with brackets: obj.array[0].property
+ */
+function getNestedValue(obj, path) {
+    if (!path || obj === null || obj === undefined) {
+        return obj;
+    }
+    // Convert [0] to .0 and split by dots
+    const parts = path.replace(/\[(\d+)\]/g, '.$1').split('.').filter(p => p !== '');
+    let current = obj;
+    for (const part of parts) {
+        if (current === null || current === undefined) {
+            return undefined;
+        }
+        current = current[part];
+    }
+    return current;
+}
+/**
+ * Converts a value to a string for use in variable substitution.
+ */
+function valueToString(value) {
+    if (value === null) {
+        return 'null';
+    }
+    if (value === undefined) {
+        return '';
+    }
+    if (typeof value === 'object') {
+        return JSON.stringify(value);
+    }
+    return String(value);
+}
+/**
+ * Substitutes variables in text.
+ * Variables are referenced as: {{variableName}} or {{variableName.property.path}}
+ * Supports nested property access for JSON objects stored as strings.
+ * Also supports object values directly (e.g., from var user = GET responses).
+ * Also supports $N response references (e.g., {{$1.status}}, {{$2.body.id}})
+ */
+function substituteVariables(text, variables) {
+    // Match {{varName}} or {{varName.path.to.property}} or {{varName[0].property}}
+    // Also match {{$N}} or {{$N.path}} for response references
+    return text.replace(/\{\{(\$\d+|[a-zA-Z_][a-zA-Z0-9_]*)((?:\.[a-zA-Z_][a-zA-Z0-9_-]*|\[\d+\])*)\}\}/g, (match, varName, pathPart) => {
+        if (!(varName in variables)) {
+            return match; // Variable not found, return original
+        }
+        const value = variables[varName];
+        // If value is already an object (e.g., HttpResponse), navigate directly
+        if (typeof value === 'object' && value !== null) {
+            if (pathPart) {
+                const path = pathPart.replace(/^\./, ''); // Remove leading dot
+                const nestedValue = getNestedValue(value, path);
+                return valueToString(nestedValue);
+            }
+            // No path, stringify the whole object
+            return valueToString(value);
+        }
+        // If there's a path and value is a string, try to parse as JSON and navigate
+        if (pathPart && typeof value === 'string') {
+            try {
+                const parsed = JSON.parse(value);
+                const path = pathPart.replace(/^\./, ''); // Remove leading dot
+                const nestedValue = getNestedValue(parsed, path);
+                return valueToString(nestedValue);
+            }
+            catch {
+                // Not valid JSON, return original value
+                return value;
+            }
+        }
+        // Simple substitution
+        return String(value);
+    });
+}
+/**
+ * Extracts a single request block from the text.
+ * Stops parsing at ### delimiter (REST Client style separator).
+ * A blank line separates headers from body (standard HTTP convention).
+ */
+function parserHttpRequest(text, variables = {}) {
+    // Substitute variables first
+    const substitutedText = substituteVariables(text, variables);
+    // Split by ### to get only the first request block
+    const requestBlock = substitutedText.split(/^###/m)[0];
+    const allLines = requestBlock.split('\n');
+    // Find the first line that looks like a request (METHOD URL)
+    const methodRegex = /^(GET|POST|PUT|DELETE|PATCH|HEAD|OPTIONS)\s+/i;
+    let requestLineIndex = -1;
+    for (let i = 0; i < allLines.length; i++) {
+        const trimmed = allLines[i].trim();
+        if (methodRegex.test(trimmed)) {
+            requestLineIndex = i;
+            break;
+        }
+    }
+    if (requestLineIndex === -1) {
+        throw new Error('No valid HTTP method found');
+    }
+    // Strip inline comments from the request line before parsing
+    let requestLine = stripInlineComment(allLines[requestLineIndex].trim());
+    // Extract retry/backoff options before parsing method/URL
+    const { cleanedLine, retryCount, backoffMs } = extractRetryOptions(requestLine);
+    requestLine = cleanedLine;
+    const [method, ...urlParts] = requestLine.split(' ');
+    let url = urlParts.join(' ');
+    // Handle quoted URLs - remove the quotes
+    if ((url.startsWith('"') && url.endsWith('"')) || (url.startsWith("'") && url.endsWith("'"))) {
+        url = url.slice(1, -1);
+    }
+    const headers = {};
+    let bodyStartIndex = -1;
+    let foundBlankLine = false;
+    // Parse headers (lines after request line until blank line or non-header)
+    // Headers must have format "Name: Value" where Name is a valid token
+    const headerRegex = /^([A-Za-z0-9\-_]+)\s*:\s*(.+)$/;
+    for (let i = requestLineIndex + 1; i < allLines.length; i++) {
+        const line = allLines[i].trim();
+        // Skip comment lines and variable declarations in header section
+        if (line.startsWith('#') || line.startsWith('var ')) {
+            continue;
+        }
+        // Blank line marks end of headers
+        if (line === '') {
+            foundBlankLine = true;
+            continue;
+        }
+        // If we've seen a blank line, everything after is body
+        if (foundBlankLine) {
+            bodyStartIndex = i;
+            break;
+        }
+        const headerMatch = line.match(headerRegex);
+        if (headerMatch) {
+            headers[headerMatch[1]] = headerMatch[2].trim();
+        }
+        else {
+            // Not a header format, must be start of body
+            bodyStartIndex = i;
+            break;
+        }
+    }
+    // Extract body - join remaining non-empty, non-comment lines
+    // Stop at next request boundary: [SomeName], sequence, or HTTP method
+    let body;
+    if (bodyStartIndex > 0) {
+        const bodyLines = [];
+        const boundaryRegex = /^\[.*\]$|^sequence\s+|^(GET|POST|PUT|DELETE|PATCH|HEAD|OPTIONS)\s+/i;
+        for (let i = bodyStartIndex; i < allLines.length; i++) {
+            const line = allLines[i].trim();
+            // Stop at request boundaries
+            if (boundaryRegex.test(line)) {
+                break;
+            }
+            // Include non-empty, non-comment, non-var lines
+            if (line && !line.startsWith('#') && !line.startsWith('var ')) {
+                bodyLines.push(line);
+            }
+        }
+        body = bodyLines.join('\n').trim();
+        if (body === '') {
+            body = undefined;
+        }
+    }
+    return { method: method.toUpperCase(), url, headers, body, retryCount, backoffMs };
+}
+const METHOD_REGEX = /^(GET|POST|PUT|DELETE|PATCH|HEAD|OPTIONS|TRACE|CONNECT)\s+/i;
+/**
+ * Checks if a line is the start of a new request (HTTP method line).
+ */
+function isRequestLine(line) {
+    return METHOD_REGEX.test(line.trim());
+}
+/**
+ * Checks if a line is a variable declaration.
+ */
+function isVariableLine(line) {
+    return /^var\s+[a-zA-Z_][a-zA-Z0-9_]*\s*=/.test(line.trim());
+}
+/**
+ * Checks if a line is the start of a sequence block.
+ */
+function isSequenceLine(line) {
+    return /^sequence\s+[a-zA-Z_][a-zA-Z0-9_-]*/.test(line.trim());
+}
+/**
+ * Finds the request block at a given line number.
+ * Request blocks are detected by HTTP method keywords (GET, POST, etc.).
+ * No need for ### separators - we detect boundaries automatically.
+ */
+function getRequestBlockAtLine(text, lineNumber) {
+    const lines = text.split('\n');
+    // First, find the request line at or before the given line number
+    let requestStartLine = -1;
+    for (let i = lineNumber; i >= 0; i--) {
+        if (isRequestLine(lines[i])) {
+            requestStartLine = i;
+            break;
+        }
+    }
+    // If no request line found above, search below (user might be on a comment above the request)
+    if (requestStartLine === -1) {
+        for (let i = lineNumber; i < lines.length; i++) {
+            if (isRequestLine(lines[i])) {
+                requestStartLine = i;
+                break;
+            }
+        }
+    }
+    if (requestStartLine === -1) {
+        return ''; // No request found
+    }
+    // Find where this request block ends (next request line or end of file)
+    let endLine = lines.length;
+    for (let i = requestStartLine + 1; i < lines.length; i++) {
+        const line = lines[i].trim();
+        // End at next request line, ### separator (still support it), sequence block, or variable declaration at file level
+        if (isRequestLine(lines[i]) || line.startsWith('###') || isSequenceLine(lines[i])) {
+            endLine = i;
+            break;
+        }
+    }
+    // Include any comments/blank lines immediately before the request
+    let startLine = requestStartLine;
+    for (let i = requestStartLine - 1; i >= 0; i--) {
+        const line = lines[i].trim();
+        if (line === '' || line.startsWith('#')) {
+            // Don't include if it's a ### separator
+            if (line.startsWith('###')) {
+                break;
+            }
+            startLine = i;
+        }
+        else if (isVariableLine(lines[i])) {
+            // Stop at variable declarations
+            break;
+        }
+        else if (isRequestLine(lines[i])) {
+            // Stop at previous request
+            break;
+        }
+        else {
+            break;
+        }
+    }
+    return lines.slice(startLine, endLine).join('\n');
+}
+/**
+ * Extracts all import statements from the document.
+ * Import syntax:
+ *   import "path/to/file.norn"  (quoted)
+ *   import './path/to/file.norn' (quoted)
+ *   import ./path/to/file.norn   (unquoted)
+ */
+function extractImports(text) {
+    const lines = text.split('\n');
+    const imports = [];
+    // Match import "path" or import 'path' (quoted)
+    const quotedImportRegex = /^\s*import\s+["'](.+?)["']\s*$/;
+    // Match import path (unquoted - path without spaces)
+    const unquotedImportRegex = /^\s*import\s+(\S+)\s*$/;
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        // Try quoted first
+        let match = line.match(quotedImportRegex);
+        if (match) {
+            imports.push({
+                path: match[1],
+                lineNumber: i
+            });
+            continue;
+        }
+        // Try unquoted
+        match = line.match(unquotedImportRegex);
+        if (match) {
+            imports.push({
+                path: match[1],
+                lineNumber: i
+            });
+        }
+    }
+    return imports;
+}
+/**
+ * Resolves all imports in a .norn file and returns the combined imported content.
+ * Only extracts named requests and sequences from imported files (not variables).
+ * Also handles .nornapi imports for header groups and endpoints.
+ * Handles circular imports by tracking the active import stack.
+ * Re-imports of already loaded files are treated as no-ops.
+ *
+ * @param text - The source text to extract imports from
+ * @param baseDir - The directory of the current file (for resolving relative paths)
+ * @param readFile - Function to read file contents (allows async filesystem access)
+ * @param alreadyImported - Set of already loaded import paths (for de-duplication)
+ * @param importStack - Set of import paths currently being resolved (for true cycle detection)
+ */
+async function resolveImports(text, baseDir, readFile, alreadyImported = new Set(), importStack = new Set()) {
+    const imports = extractImports(text);
+    const errors = [];
+    const importedContents = [];
+    const resolvedPaths = [];
+    const headerGroups = [];
+    const endpoints = [];
+    // Track sources for duplicate detection
+    const headerGroupSources = new Map();
+    const endpointSources = new Map();
+    const namedRequestSources = new Map();
+    const sequenceSources = new Map();
+    for (const imp of imports) {
+        // Resolve the path relative to baseDir
+        const path = await import('path');
+        const absolutePath = path.resolve(baseDir, imp.path);
+        // Circular import only when the file is in the active import stack.
+        if (importStack.has(absolutePath)) {
+            errors.push({
+                path: imp.path,
+                error: `Circular import detected`,
+                lineNumber: imp.lineNumber
+            });
+            continue;
+        }
+        // Duplicate import of an already loaded file: skip silently.
+        if (alreadyImported.has(absolutePath)) {
+            continue;
+        }
+        try {
+            const content = await readFile(absolutePath);
+            alreadyImported.add(absolutePath);
+            importStack.add(absolutePath);
+            resolvedPaths.push(absolutePath);
+            // Check if this is a .nornapi file
+            if (imp.path.endsWith('.nornapi')) {
+                // Parse the .nornapi file
+                const apiDef = (0, nornapiParser_1.parseNornApiFile)(content);
+                // Check for duplicate header groups
+                for (const group of apiDef.headerGroups) {
+                    const existingSource = headerGroupSources.get(group.name);
+                    if (existingSource) {
+                        errors.push({
+                            path: imp.path,
+                            error: `Duplicate header group '${group.name}': already defined in '${existingSource}'`,
+                            lineNumber: imp.lineNumber
+                        });
+                    }
+                    else {
+                        headerGroupSources.set(group.name, imp.path);
+                        headerGroups.push(group);
+                    }
+                }
+                // Check for duplicate endpoints
+                for (const endpoint of apiDef.endpoints) {
+                    const existingSource = endpointSources.get(endpoint.name);
+                    if (existingSource) {
+                        errors.push({
+                            path: imp.path,
+                            error: `Duplicate endpoint '${endpoint.name}': already defined in '${existingSource}'`,
+                            lineNumber: imp.lineNumber
+                        });
+                    }
+                    else {
+                        endpointSources.set(endpoint.name, imp.path);
+                        endpoints.push(endpoint);
+                    }
+                }
+                continue;
+            }
+            // Regular .norn file - process as before
+            // Recursively resolve imports in the imported file
+            const importDir = path.dirname(absolutePath);
+            const nestedResult = await resolveImports(content, importDir, readFile, alreadyImported, importStack);
+            // Add nested errors
+            errors.push(...nestedResult.errors);
+            resolvedPaths.push(...nestedResult.resolvedPaths);
+            // Add nested API definitions with duplicate checking
+            for (const group of nestedResult.headerGroups) {
+                const existingSource = headerGroupSources.get(group.name);
+                if (existingSource) {
+                    errors.push({
+                        path: imp.path,
+                        error: `Duplicate header group '${group.name}': already defined in '${existingSource}'`,
+                        lineNumber: imp.lineNumber
+                    });
+                }
+                else {
+                    headerGroupSources.set(group.name, imp.path);
+                    headerGroups.push(group);
+                }
+            }
+            for (const endpoint of nestedResult.endpoints) {
+                const existingSource = endpointSources.get(endpoint.name);
+                if (existingSource) {
+                    errors.push({
+                        path: imp.path,
+                        error: `Duplicate endpoint '${endpoint.name}': already defined in '${existingSource}'`,
+                        lineNumber: imp.lineNumber
+                    });
+                }
+                else {
+                    endpointSources.set(endpoint.name, imp.path);
+                    endpoints.push(endpoint);
+                }
+            }
+            // Add nested imported content first (dependencies first)
+            if (nestedResult.importedContent) {
+                importedContents.push(nestedResult.importedContent);
+            }
+            // Extract only file-level variables to resolve references in imported requests/sequences.
+            // Sequence-local vars must stay runtime-evaluated and must not be pre-baked.
+            const importedVariables = extractFileLevelVariables(content);
+            const importedNamedRequests = extractNamedRequests(content);
+            const importedSequences = extractSequencesFromText(content);
+            // Reconstruct named requests with variables already substituted (with duplicate checking)
+            for (const req of importedNamedRequests) {
+                const lowerName = req.name.toLowerCase();
+                const existingSource = namedRequestSources.get(lowerName);
+                if (existingSource) {
+                    errors.push({
+                        path: imp.path,
+                        error: `Duplicate named request '${req.name}': already defined in '${existingSource}'`,
+                        lineNumber: imp.lineNumber
+                    });
+                }
+                else {
+                    namedRequestSources.set(lowerName, imp.path);
+                    const resolvedContent = substituteVariables(req.content, importedVariables);
+                    importedContents.push(`[${req.name}]\n${resolvedContent}`);
+                }
+            }
+            // Reconstruct sequences with variables already substituted (with duplicate checking)
+            for (const seq of importedSequences) {
+                const lowerName = seq.name.toLowerCase();
+                const existingSource = sequenceSources.get(lowerName);
+                if (existingSource) {
+                    errors.push({
+                        path: imp.path,
+                        error: `Duplicate sequence '${seq.name}': already defined in '${existingSource}'`,
+                        lineNumber: imp.lineNumber
+                    });
+                }
+                else {
+                    // Store the ABSOLUTE path so script paths can be resolved correctly
+                    sequenceSources.set(lowerName, absolutePath);
+                    const resolvedContent = substituteVariables(seq.content, importedVariables);
+                    importedContents.push(`sequence ${seq.name}\n${resolvedContent}\nend sequence`);
+                }
+            }
+        }
+        catch (error) {
+            errors.push({
+                path: imp.path,
+                error: error.message || 'Failed to read file',
+                lineNumber: imp.lineNumber
+            });
+        }
+        finally {
+            importStack.delete(absolutePath);
+        }
+    }
+    return {
+        importedContent: importedContents.join('\n\n'),
+        errors,
+        resolvedPaths,
+        headerGroups,
+        endpoints,
+        sequenceSources
+    };
+}
+/**
+ * Helper function to extract sequences from text without importing sequenceRunner
+ * (avoids circular dependencies)
+ */
+function extractSequencesFromText(text) {
+    const lines = text.split('\n');
+    const sequences = [];
+    let currentSequence = null;
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i].trim();
+        // Check for sequence start
+        const sequenceMatch = line.match(/^sequence\s+([a-zA-Z_][a-zA-Z0-9_-]*)$/);
+        if (sequenceMatch) {
+            currentSequence = {
+                name: sequenceMatch[1],
+                lines: []
+            };
+            continue;
+        }
+        // Check for sequence end
+        if (line === 'end sequence' && currentSequence) {
+            sequences.push({
+                name: currentSequence.name,
+                content: currentSequence.lines.join('\n')
+            });
+            currentSequence = null;
+            continue;
+        }
+        // Add line to current sequence
+        if (currentSequence) {
+            currentSequence.lines.push(lines[i]);
+        }
+    }
+    return sequences;
+}
+//# sourceMappingURL=parser.js.map