norn-cli 2.3.0 → 2.4.0

package/out/debug/nornDebugSession.js

@@ -0,0 +1,613 @@
+"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.NornDebugSession = void 0;
+const fs = __importStar(require("fs/promises"));
+const path = __importStar(require("path"));
+const parser_1 = require("../parser");
+const sequenceRunner_1 = require("../sequenceRunner");
+const responsePanel_1 = require("../responsePanel");
+const environmentProvider_1 = require("../environmentProvider");
+const formatError_1 = require("../errors/formatError");
+const importErrors_1 = require("../importErrors");
+const breakpointResolver_1 = require("./breakpointResolver");
+const sequenceLocationIndex_1 = require("./sequenceLocationIndex");
+const THREAD_ID = 1;
+function isObjectLike(value) {
+    return typeof value === 'object' && value !== null;
+}
+function formatVariableValue(value) {
+    if (value === null) {
+        return 'null';
+    }
+    if (value === undefined) {
+        return 'undefined';
+    }
+    if (typeof value === 'string') {
+        return value;
+    }
+    if (typeof value === 'number' || typeof value === 'boolean') {
+        return String(value);
+    }
+    if (Array.isArray(value)) {
+        return `Array(${value.length})`;
+    }
+    return 'Object';
+}
+class NornDebugSession {
+    send;
+    extensionUri;
+    outgoingSeq = 1;
+    launchConfig;
+    configurationDone = false;
+    launchStarted = false;
+    terminated = false;
+    breakpointsByFile = new Map();
+    continueMode = 'continue';
+    stepDepthTarget = 0;
+    pauseRequested = false;
+    waitForResume;
+    resumeResolver;
+    stopOnEntryConsumed = false;
+    frames = [];
+    nextFrameId = 1;
+    pausedState;
+    lastStepEvent;
+    failurePauseHandled = false;
+    runtimeVariables = {};
+    responses = [];
+    variableHandles = new Map();
+    nextVariableHandle = 1;
+    constructor(extensionUri, send) {
+        this.extensionUri = extensionUri;
+        this.send = send;
+    }
+    async handleRequest(request) {
+        try {
+            switch (request.command) {
+                case 'initialize':
+                    this.handleInitialize(request);
+                    return;
+                case 'launch':
+                    this.handleLaunch(request);
+                    return;
+                case 'setBreakpoints':
+                    await this.handleSetBreakpoints(request);
+                    return;
+                case 'configurationDone':
+                    this.handleConfigurationDone(request);
+                    return;
+                case 'threads':
+                    this.handleThreads(request);
+                    return;
+                case 'stackTrace':
+                    this.handleStackTrace(request);
+                    return;
+                case 'scopes':
+                    this.handleScopes(request);
+                    return;
+                case 'variables':
+                    this.handleVariables(request);
+                    return;
+                case 'continue':
+                    this.handleContinue(request);
+                    return;
+                case 'next':
+                    this.handleNext(request);
+                    return;
+                case 'stepIn':
+                    this.handleStepIn(request);
+                    return;
+                case 'stepOut':
+                    this.handleStepOut(request);
+                    return;
+                case 'pause':
+                    this.handlePause(request);
+                    return;
+                case 'disconnect':
+                case 'terminate':
+                    this.handleDisconnect(request);
+                    return;
+                default:
+                    this.sendErrorResponse(request, `Unsupported command: ${request.command}`);
+            }
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            this.sendErrorResponse(request, message);
+        }
+    }
+    handleInitialize(request) {
+        this.sendResponse(request, {
+            supportsConfigurationDoneRequest: true,
+            supportsTerminateRequest: true,
+            supportsConditionalBreakpoints: false,
+            supportsHitConditionalBreakpoints: false,
+            supportsLogPoints: false
+        });
+        this.sendEvent('initialized');
+    }
+    handleLaunch(request) {
+        const config = request.arguments;
+        if (!config || !config.file || !config.sequence) {
+            this.sendErrorResponse(request, 'Launch requires file and sequence');
+            return;
+        }
+        this.launchConfig = {
+            ...config,
+            file: path.resolve(config.file),
+            stopOnEntry: config.stopOnEntry ?? true
+        };
+        this.sendResponse(request);
+        if (this.configurationDone && !this.launchStarted) {
+            this.startLaunch();
+        }
+    }
+    async handleSetBreakpoints(request) {
+        const args = request.arguments || {};
+        const sourcePath = typeof args?.source?.path === 'string' ? path.resolve(args.source.path) : undefined;
+        if (!sourcePath) {
+            this.sendResponse(request, { breakpoints: [] });
+            return;
+        }
+        const requestedLines = Array.isArray(args.lines)
+            ? args.lines
+            : Array.isArray(args.breakpoints)
+                ? args.breakpoints.map((bp) => bp?.line).filter((line) => typeof line === 'number')
+                : [];
+        const resolved = await (0, breakpointResolver_1.resolveBreakpointsForFile)(sourcePath, requestedLines);
+        const verified = new Set();
+        for (const item of resolved) {
+            if (item.verified) {
+                verified.add(item.line);
+            }
+        }
+        this.breakpointsByFile.set(sourcePath, verified);
+        this.sendResponse(request, {
+            breakpoints: resolved.map(item => ({
+                verified: item.verified,
+                line: item.line,
+                message: item.message
+            }))
+        });
+    }
+    handleConfigurationDone(request) {
+        this.configurationDone = true;
+        this.sendResponse(request);
+        if (this.launchConfig && !this.launchStarted) {
+            this.startLaunch();
+        }
+    }
+    handleThreads(request) {
+        this.sendResponse(request, {
+            threads: [{ id: THREAD_ID, name: 'Norn' }]
+        });
+    }
+    handleStackTrace(request) {
+        const ordered = [...this.frames].sort((a, b) => b.nestingDepth - a.nestingDepth);
+        const stackFrames = ordered.map(frame => {
+            const lineZero = frame.currentLine ?? frame.declarationLine ?? 0;
+            const sourcePath = frame.filePath;
+            return {
+                id: frame.id,
+                name: frame.sequenceName,
+                source: sourcePath
+                    ? { name: path.basename(sourcePath), path: sourcePath }
+                    : undefined,
+                line: lineZero + 1,
+                column: 1
+            };
+        });
+        this.sendResponse(request, {
+            stackFrames,
+            totalFrames: stackFrames.length
+        });
+    }
+    handleScopes(request) {
+        const runtimeRef = this.createVariableReference(this.runtimeVariables);
+        const responsesObject = {};
+        this.responses.forEach((resp, idx) => {
+            responsesObject[`$${idx + 1}`] = resp;
+        });
+        const responsesRef = this.createVariableReference(responsesObject);
+        this.sendResponse(request, {
+            scopes: [
+                {
+                    name: 'Runtime Variables',
+                    variablesReference: runtimeRef,
+                    expensive: false
+                },
+                {
+                    name: 'Responses',
+                    variablesReference: responsesRef,
+                    expensive: false
+                }
+            ]
+        });
+    }
+    handleVariables(request) {
+        const args = request.arguments || {};
+        const handle = typeof args.variablesReference === 'number' ? args.variablesReference : 0;
+        const value = this.variableHandles.get(handle);
+        if (value === undefined) {
+            this.sendResponse(request, { variables: [] });
+            return;
+        }
+        const variables = [];
+        if (Array.isArray(value)) {
+            value.forEach((item, idx) => {
+                variables.push({
+                    name: String(idx),
+                    value: formatVariableValue(item),
+                    variablesReference: this.createVariableReference(item),
+                    type: Array.isArray(item) ? 'array' : typeof item
+                });
+            });
+        }
+        else if (isObjectLike(value)) {
+            for (const [key, item] of Object.entries(value)) {
+                variables.push({
+                    name: key,
+                    value: formatVariableValue(item),
+                    variablesReference: this.createVariableReference(item),
+                    type: Array.isArray(item) ? 'array' : typeof item
+                });
+            }
+        }
+        this.sendResponse(request, { variables });
+    }
+    handleContinue(request) {
+        this.continueMode = 'continue';
+        this.resumeExecution();
+        this.sendResponse(request, { allThreadsContinued: true });
+    }
+    handleNext(request) {
+        this.continueMode = 'next';
+        this.stepDepthTarget = Math.max(1, this.frames.length);
+        this.resumeExecution();
+        this.sendResponse(request);
+    }
+    handleStepIn(request) {
+        this.continueMode = 'stepIn';
+        this.resumeExecution();
+        this.sendResponse(request);
+    }
+    handleStepOut(request) {
+        this.continueMode = 'stepOut';
+        this.stepDepthTarget = Math.max(0, this.frames.length - 1);
+        this.resumeExecution();
+        this.sendResponse(request);
+    }
+    handlePause(request) {
+        this.pauseRequested = true;
+        this.sendResponse(request);
+    }
+    handleDisconnect(request) {
+        this.terminated = true;
+        this.resumeExecution();
+        this.sendResponse(request);
+        this.sendEvent('terminated');
+    }
+    createVariableReference(value) {
+        if (!isObjectLike(value) && !Array.isArray(value)) {
+            return 0;
+        }
+        const handle = this.nextVariableHandle++;
+        this.variableHandles.set(handle, value);
+        return handle;
+    }
+    resetVariableHandles() {
+        this.variableHandles.clear();
+        this.nextVariableHandle = 1;
+    }
+    startLaunch() {
+        if (this.launchStarted) {
+            return;
+        }
+        this.launchStarted = true;
+        void this.runLaunch();
+    }
+    async runLaunch() {
+        if (!this.launchConfig) {
+            return;
+        }
+        this.sendEvent('thread', { reason: 'started', threadId: THREAD_ID });
+        const config = this.launchConfig;
+        const previousEnv = (0, environmentProvider_1.getActiveEnvironment)(config.file);
+        try {
+            await this.validateEnvironmentSelection(config.file, config.env);
+            if (config.env) {
+                (0, environmentProvider_1.setActiveEnvironment)(config.env, config.file);
+            }
+            await this.ensureEnvironmentReady(config.file);
+            const fileContent = await fs.readFile(config.file, 'utf-8');
+            const importResult = await (0, parser_1.resolveImports)(fileContent, path.dirname(config.file), async (importPath) => fs.readFile(importPath, 'utf-8'), undefined, undefined, config.file);
+            const duplicateErrors = (0, importErrors_1.getBlockingImportErrors)(importResult.errors);
+            if (duplicateErrors.length > 0) {
+                throw new Error(`Cannot debug sequence due to blocking import errors: ${duplicateErrors[0].error}`);
+            }
+            const fullTextWithImports = importResult.importedContent
+                ? `${importResult.importedContent}\n\n${fileContent}`
+                : fileContent;
+            const sequence = (0, sequenceRunner_1.extractSequences)(fullTextWithImports).find(seq => seq.name === config.sequence);
+            if (!sequence) {
+                throw new Error(`Sequence '${config.sequence}' not found`);
+            }
+            const locationIndex = await (0, sequenceLocationIndex_1.buildSequenceLocationIndex)(config.file, importResult.sequenceSources);
+            const location = locationIndex.get(sequence.name.toLowerCase());
+            const envVars = (0, environmentProvider_1.getEnvironmentVariables)(config.file);
+            const fileVariables = (0, parser_1.extractFileLevelVariables)(fileContent);
+            const allVariables = (0, parser_1.attachEnvironmentScope)({ ...envVars, ...fileVariables }, envVars);
+            const defaultArgs = {};
+            if (sequence.parameters) {
+                for (const param of sequence.parameters) {
+                    if (param.defaultValue !== undefined) {
+                        defaultArgs[param.name] = param.defaultValue;
+                    }
+                }
+            }
+            const runArgs = { ...defaultArgs, ...(config.args || {}) };
+            const apiDefinitions = (importResult.headerGroups?.length || 0) > 0 || (importResult.endpoints?.length || 0) > 0
+                ? { headerGroups: importResult.headerGroups || [], endpoints: importResult.endpoints || [] }
+                : undefined;
+            const envValidationContext = this.getEnvironmentValidationContext(config.file);
+            const executionContext = {
+                filePath: location?.filePath ?? config.file,
+                sequenceName: sequence.name,
+                environment: envValidationContext,
+                sequenceStartLine: location?.startLine ?? sequence.startLine,
+                sequenceLocationIndex: locationIndex
+            };
+            this.frames = [];
+            this.pauseRequested = false;
+            this.stopOnEntryConsumed = false;
+            this.failurePauseHandled = false;
+            this.runtimeVariables = allVariables;
+            this.responses = [];
+            responsePanel_1.ResponsePanel.startSequenceRun(this.extensionUri, sequence.name, (0, sequenceRunner_1.countSequenceSteps)(sequence.content), config.file);
+            const debugHooks = {
+                onSequenceEnter: (info) => this.onSequenceEnter(info),
+                onSequenceExit: (info) => this.onSequenceExit(info),
+                beforeStep: (event) => this.onBeforeStep(event),
+                onFailure: async (failure) => {
+                    const event = this.lastStepEvent;
+                    if (!event) {
+                        return;
+                    }
+                    this.failurePauseHandled = true;
+                    await this.pauseExecution('exception', event, failure.message);
+                }
+            };
+            const result = await (0, sequenceRunner_1.runSequence)(sequence.content, allVariables, path.dirname(config.file), fullTextWithImports, (progress) => this.onProgress(progress), undefined, runArgs, apiDefinitions, undefined, importResult.sequenceSources, importResult.sqlOperationsBySource, executionContext, debugHooks);
+            result.name = sequence.name;
+            responsePanel_1.ResponsePanel.finalizeSequence(result);
+            if (!result.success && this.lastStepEvent && !this.pausedState && !this.failurePauseHandled) {
+                await this.pauseExecution('exception', this.lastStepEvent, result.errors[0] || 'Sequence failed');
+            }
+        }
+        catch (error) {
+            const message = (0, formatError_1.formatUserFacingError)(error, {
+                source: 'extension',
+                filePath: this.launchConfig.file,
+                sequenceName: this.launchConfig.sequence,
+                environment: this.getEnvironmentValidationContext(this.launchConfig.file)
+            });
+            this.sendEvent('output', {
+                category: 'stderr',
+                output: `Norn debug error: ${message}\n`
+            });
+            responsePanel_1.ResponsePanel.finalizeSequence({
+                name: this.launchConfig.sequence,
+                success: false,
+                responses: [],
+                scriptResults: [],
+                assertionResults: [],
+                steps: [],
+                errors: [message],
+                duration: 0
+            });
+        }
+        finally {
+            if (config.env) {
+                (0, environmentProvider_1.setActiveEnvironment)(previousEnv, config.file);
+            }
+            this.sendEvent('thread', { reason: 'exited', threadId: THREAD_ID });
+            this.sendEvent('terminated');
+        }
+    }
+    getEnvironmentValidationContext(filePath) {
+        return {
+            hasEnvFile: (0, environmentProvider_1.getAvailableEnvironments)(filePath).length > 0,
+            activeEnvironment: (0, environmentProvider_1.getActiveEnvironment)(filePath),
+            availableEnvironments: (0, environmentProvider_1.getAvailableEnvironments)(filePath)
+        };
+    }
+    async validateEnvironmentSelection(filePath, env) {
+        if (!env) {
+            return;
+        }
+        const available = (0, environmentProvider_1.getAvailableEnvironments)(filePath);
+        if (!available.includes(env)) {
+            throw new Error(`Environment '${env}' not found. Available: ${available.join(', ') || 'none'}`);
+        }
+    }
+    async ensureEnvironmentReady(filePath) {
+        const envErrors = (0, environmentProvider_1.getEnvironmentImportErrorDetails)(filePath);
+        if (envErrors.length > 0) {
+            throw new Error(`.nornenv has errors: ${envErrors[0].message}`);
+        }
+        const unlocked = await (0, environmentProvider_1.promptForMissingEnvironmentSecretKeys)(filePath);
+        if (!unlocked) {
+            throw new Error('Secrets are locked. Enter shared key to continue.');
+        }
+        const secretErrors = (0, environmentProvider_1.getEnvironmentSecretErrorDetails)(filePath);
+        if (secretErrors.length > 0) {
+            throw new Error(`.nornenv secret error: ${secretErrors[0].message}`);
+        }
+    }
+    onProgress(progress) {
+        const prefix = progress.nestingDepth && progress.nestingDepth > 0 ? `${'  '.repeat(progress.nestingDepth)}` : '';
+        this.sendEvent('output', {
+            category: 'console',
+            output: `${prefix}[${progress.currentStep}/${progress.totalSteps}] ${progress.stepDescription}\n`
+        });
+        if (progress.stepType === 'sequenceStart' || progress.stepType === 'sequenceEnd') {
+            responsePanel_1.ResponsePanel.addSequenceStep(undefined, progress);
+        }
+        else if (progress.stepResult) {
+            responsePanel_1.ResponsePanel.addSequenceStep(progress.stepResult, progress);
+        }
+    }
+    async onSequenceEnter(info) {
+        const frame = {
+            id: this.nextFrameId++,
+            sequenceName: info.sequenceName || 'sequence',
+            filePath: info.filePath,
+            declarationLine: info.declarationLine,
+            currentLine: info.declarationLine,
+            nestingDepth: info.nestingDepth
+        };
+        this.frames.push(frame);
+    }
+    async onSequenceExit(info) {
+        while (this.frames.length > info.nestingDepth) {
+            this.frames.pop();
+        }
+    }
+    async onBeforeStep(event) {
+        if (this.terminated) {
+            throw new Error('Debug session terminated');
+        }
+        this.lastStepEvent = event;
+        this.runtimeVariables = event.runtimeVariables;
+        this.responses = event.responses;
+        const currentFrame = this.frames[this.frames.length - 1];
+        if (currentFrame && event.location.absoluteLine !== undefined) {
+            currentFrame.currentLine = event.location.absoluteLine;
+        }
+        const currentDepth = Math.max(1, this.frames.length);
+        let reason;
+        if (!this.stopOnEntryConsumed && (this.launchConfig?.stopOnEntry ?? true)) {
+            reason = 'entry';
+            this.stopOnEntryConsumed = true;
+        }
+        else if (this.pauseRequested) {
+            reason = 'pause';
+            this.pauseRequested = false;
+        }
+        else if (this.continueMode === 'stepIn') {
+            reason = 'step';
+        }
+        else if (this.continueMode === 'next' && currentDepth <= this.stepDepthTarget) {
+            reason = 'step';
+        }
+        else if (this.continueMode === 'stepOut' && currentDepth <= this.stepDepthTarget) {
+            reason = 'step';
+        }
+        else if (event.location.filePath && event.location.absoluteLine !== undefined) {
+            const filePath = path.resolve(event.location.filePath);
+            const lineOneBased = event.location.absoluteLine + 1;
+            const fileBreakpoints = this.breakpointsByFile.get(filePath);
+            if (fileBreakpoints && fileBreakpoints.has(lineOneBased)) {
+                reason = 'breakpoint';
+            }
+        }
+        if (!reason) {
+            return;
+        }
+        await this.pauseExecution(reason, event);
+    }
+    async pauseExecution(reason, event, message) {
+        if (this.terminated) {
+            throw new Error('Debug session terminated');
+        }
+        this.pausedState = { reason, event, message };
+        this.resetVariableHandles();
+        this.sendEvent('stopped', {
+            reason,
+            threadId: THREAD_ID,
+            description: message,
+            allThreadsStopped: true
+        });
+        this.waitForResume = new Promise((resolve) => {
+            this.resumeResolver = resolve;
+        });
+        await this.waitForResume;
+        this.waitForResume = undefined;
+        this.resumeResolver = undefined;
+        this.pausedState = undefined;
+        if (this.terminated) {
+            throw new Error('Debug session terminated');
+        }
+    }
+    resumeExecution() {
+        if (this.resumeResolver) {
+            this.resumeResolver();
+        }
+    }
+    sendResponse(request, body) {
+        const response = {
+            seq: this.outgoingSeq++,
+            type: 'response',
+            request_seq: request.seq,
+            command: request.command,
+            success: true,
+            body
+        };
+        this.send(response);
+    }
+    sendErrorResponse(request, message) {
+        const response = {
+            seq: this.outgoingSeq++,
+            type: 'response',
+            request_seq: request.seq,
+            command: request.command,
+            success: false,
+            message
+        };
+        this.send(response);
+    }
+    sendEvent(event, body) {
+        const output = {
+            seq: this.outgoingSeq++,
+            type: 'event',
+            event,
+            body
+        };
+        this.send(output);
+    }
+}
+exports.NornDebugSession = NornDebugSession;
+//# sourceMappingURL=nornDebugSession.js.map

package/out/debug/sequenceLocationIndex.js

@@ -0,0 +1,77 @@
+"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.buildSequenceLocationIndex = buildSequenceLocationIndex;
+const fs = __importStar(require("fs/promises"));
+const sequenceRunner_1 = require("../sequenceRunner");
+const sequenceDeclaration_1 = require("../sequenceDeclaration");
+async function indexFile(filePath, index, readFile, visited) {
+    if (visited.has(filePath)) {
+        return;
+    }
+    visited.add(filePath);
+    const content = await readFile(filePath);
+    const lines = content.split('\n');
+    const sequences = (0, sequenceRunner_1.extractSequences)(content);
+    for (const seq of sequences) {
+        const key = seq.name.toLowerCase();
+        if (index.has(key)) {
+            continue;
+        }
+        const declarationLine = (0, sequenceDeclaration_1.findSequenceDeclarationLine)(lines, seq.startLine, seq.endLine);
+        const entry = {
+            filePath,
+            sequenceName: seq.name,
+            declarationLine,
+            startLine: declarationLine,
+            endLine: seq.endLine
+        };
+        index.set(key, entry);
+    }
+}
+/**
+ * Builds a sequence location index for root file and imported sequence sources.
+ */
+async function buildSequenceLocationIndex(rootFilePath, importedSequenceSources, readFile = (p) => fs.readFile(p, 'utf-8')) {
+    const index = new Map();
+    const visited = new Set();
+    await indexFile(rootFilePath, index, readFile, visited);
+    const importedFiles = new Set(Array.from(importedSequenceSources.values()));
+    for (const filePath of importedFiles) {
+        await indexFile(filePath, index, readFile, visited);
+    }
+    return index;
+}
+//# sourceMappingURL=sequenceLocationIndex.js.map

package/out/debug/types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=types.js.map