norn-cli 2.2.2 → 2.4.0

package/out/mcpConfig.js

@@ -0,0 +1,184 @@
+"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.loadNornMcpProjectConfig = loadNornMcpProjectConfig;
+exports.loadResolvedNornMcpProjectConfig = loadResolvedNornMcpProjectConfig;
+exports.resolveMcpServer = resolveMcpServer;
+const path = __importStar(require("path"));
+const parser_1 = require("./parser");
+const nornConfig_1 = require("./nornConfig");
+function isRawMcpStdioServerConfig(value) {
+    if (!(0, nornConfig_1.isObjectRecord)(value)) {
+        return false;
+    }
+    if (value.transport !== 'stdio') {
+        return false;
+    }
+    if (!Array.isArray(value.command) || value.command.length === 0) {
+        return false;
+    }
+    if (!value.command.every(part => typeof part === 'string' && part.length > 0)) {
+        return false;
+    }
+    if (value.cwd !== undefined && typeof value.cwd !== 'string') {
+        return false;
+    }
+    return true;
+}
+function isRawMcpHttpServerConfig(value) {
+    if (!(0, nornConfig_1.isObjectRecord)(value)) {
+        return false;
+    }
+    if (value.transport !== 'http') {
+        return false;
+    }
+    if (typeof value.url !== 'string' || value.url.length === 0) {
+        return false;
+    }
+    if (value.headers !== undefined && !(0, nornConfig_1.isStringRecord)(value.headers)) {
+        return false;
+    }
+    if (value.timeoutMs !== undefined && (typeof value.timeoutMs !== 'number' || !Number.isFinite(value.timeoutMs) || value.timeoutMs <= 0)) {
+        return false;
+    }
+    return true;
+}
+function isNornMcpProjectConfig(value) {
+    if (!(0, nornConfig_1.isObjectRecord)(value)) {
+        return false;
+    }
+    const servers = value.servers;
+    if (!servers || typeof servers !== 'object' || Array.isArray(servers)) {
+        return false;
+    }
+    return Object.values(servers).every(server => isRawMcpStdioServerConfig(server) || isRawMcpHttpServerConfig(server));
+}
+function resolveTemplateString(value, envVariables) {
+    if (!envVariables) {
+        return value;
+    }
+    const scopedVariables = (0, parser_1.attachEnvironmentScope)({}, envVariables);
+    return (0, parser_1.substituteVariables)(value, scopedVariables);
+}
+function resolveCommandParts(configPath, command, envVariables) {
+    const configDir = path.dirname(configPath);
+    return command.map((part, index) => {
+        const resolvedPart = resolveTemplateString(part, envVariables);
+        if (!resolvedPart) {
+            return resolvedPart;
+        }
+        if (index === 0) {
+            if (path.isAbsolute(resolvedPart) || (!resolvedPart.startsWith('.') && !resolvedPart.includes(path.sep) && !resolvedPart.includes('/'))) {
+                return resolvedPart;
+            }
+            return path.resolve(configDir, resolvedPart);
+        }
+        if (resolvedPart.startsWith('.')) {
+            return path.resolve(configDir, resolvedPart);
+        }
+        return resolvedPart;
+    });
+}
+function resolveRelativeDirectory(configPath, value, envVariables) {
+    if (!value) {
+        return undefined;
+    }
+    const resolvedValue = resolveTemplateString(value, envVariables);
+    if (!resolvedValue) {
+        return resolvedValue;
+    }
+    if (path.isAbsolute(resolvedValue)) {
+        return resolvedValue;
+    }
+    return path.resolve(path.dirname(configPath), resolvedValue);
+}
+function resolveHeaders(headers, envVariables) {
+    if (!headers) {
+        return undefined;
+    }
+    const resolved = {};
+    for (const [key, value] of Object.entries(headers)) {
+        resolved[key] = resolveTemplateString(value, envVariables);
+    }
+    return resolved;
+}
+function resolveServerConfig(filePath, config, envVariables) {
+    if (config.transport === 'stdio') {
+        return {
+            transport: 'stdio',
+            command: resolveCommandParts(filePath, config.command, envVariables),
+            cwd: resolveRelativeDirectory(filePath, config.cwd, envVariables)
+        };
+    }
+    return {
+        transport: 'http',
+        url: resolveTemplateString(config.url, envVariables),
+        headers: resolveHeaders(config.headers, envVariables),
+        timeoutMs: config.timeoutMs
+    };
+}
+function loadNornMcpProjectConfig(startPath) {
+    const { filePath, section } = (0, nornConfig_1.loadNornConfigSection)(startPath, 'mcp', isNornMcpProjectConfig);
+    return {
+        filePath,
+        config: {
+            ...section,
+            version: 1
+        }
+    };
+}
+function loadResolvedNornMcpProjectConfig(startPath, envVariables) {
+    const { filePath, config } = loadNornMcpProjectConfig(startPath);
+    const resolvedServers = {};
+    for (const [alias, serverConfig] of Object.entries(config.servers)) {
+        resolvedServers[alias] = resolveServerConfig(filePath, serverConfig, envVariables);
+    }
+    return {
+        filePath,
+        config: {
+            version: 1,
+            servers: resolvedServers
+        }
+    };
+}
+function resolveMcpServer(startPath, alias, envVariables) {
+    const { filePath, config } = loadResolvedNornMcpProjectConfig(startPath, envVariables);
+    const server = config.servers[alias];
+    if (!server) {
+        throw new Error(`Server alias '${alias}' was not found in ${nornConfig_1.NORN_CONFIG_FILENAME} mcp.servers`);
+    }
+    return { filePath, server };
+}
+//# sourceMappingURL=mcpConfig.js.map

package/out/mcpToolIntellisenseCache.js

@@ -0,0 +1,96 @@
+"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.saveMcpToolsForAlias = saveMcpToolsForAlias;
+exports.getCachedMcpToolsForAlias = getCachedMcpToolsForAlias;
+exports.getCachedMcpToolForAlias = getCachedMcpToolForAlias;
+const path = __importStar(require("path"));
+const cacheDir_1 = require("./cacheDir");
+const mcpConfig_1 = require("./mcpConfig");
+const deepClone_1 = require("./deepClone");
+const CACHE_VERSION = 1;
+const CACHE_FILE = 'mcp-tool-intellisense.json';
+function getCachePathForConfig(configPath) {
+    return (0, cacheDir_1.getNornCacheFilePath)(path.dirname(configPath), CACHE_FILE);
+}
+function ensureCacheDirForConfig(configPath) {
+    return !!(0, cacheDir_1.ensureNornCacheDir)(path.dirname(configPath));
+}
+function loadCacheForConfig(configPath) {
+    return (0, cacheDir_1.loadVersionedJsonCache)({
+        cachePath: getCachePathForConfig(configPath),
+        version: CACHE_VERSION,
+        createDefault: () => ({ version: CACHE_VERSION, servers: {} }),
+        isValid: cache => typeof cache.servers === 'object' && cache.servers !== null
+    });
+}
+function saveCacheForConfig(configPath, cache) {
+    return (0, cacheDir_1.saveVersionedJsonCache)(getCachePathForConfig(configPath), cache, () => ensureCacheDirForConfig(configPath));
+}
+function toCachedMcpTool(tool) {
+    return {
+        name: tool.name,
+        description: typeof tool.description === 'string' ? tool.description : undefined,
+        inputSchema: (0, deepClone_1.cloneSerializableValue)(tool.inputSchema)
+    };
+}
+function saveMcpToolsForAlias(configPath, alias, tools) {
+    const cache = loadCacheForConfig(configPath);
+    cache.servers[alias.toLowerCase()] = {
+        alias,
+        cachedAt: new Date().toISOString(),
+        tools: tools.map(tool => toCachedMcpTool(tool))
+    };
+    saveCacheForConfig(configPath, cache);
+}
+function getCachedMcpToolsForAlias(startPath, alias) {
+    let configPath;
+    try {
+        configPath = (0, mcpConfig_1.loadNornMcpProjectConfig)(startPath).filePath;
+    }
+    catch {
+        return undefined;
+    }
+    const cache = loadCacheForConfig(configPath);
+    return cache.servers[alias.toLowerCase()];
+}
+function getCachedMcpToolForAlias(startPath, alias, toolName) {
+    const cachedTools = getCachedMcpToolsForAlias(startPath, alias);
+    if (!cachedTools) {
+        return undefined;
+    }
+    return cachedTools.tools.find(tool => tool.name.toLowerCase() === toolName.toLowerCase());
+}
+//# sourceMappingURL=mcpToolIntellisenseCache.js.map

package/out/mcpToolSchema.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMcpToolInputPropertyMap = getMcpToolInputPropertyMap;
+exports.getMcpToolInputParameterNames = getMcpToolInputParameterNames;
+exports.getMcpToolRequiredParameterNames = getMcpToolRequiredParameterNames;
+exports.mcpToolAllowsAdditionalProperties = mcpToolAllowsAdditionalProperties;
+function getInputSchemaObject(source) {
+    if (!source.inputSchema || typeof source.inputSchema !== 'object' || Array.isArray(source.inputSchema)) {
+        return undefined;
+    }
+    return source.inputSchema;
+}
+function getMcpToolInputPropertyMap(source) {
+    const schema = getInputSchemaObject(source);
+    if (!schema) {
+        return {};
+    }
+    const properties = schema.properties;
+    if (!properties || typeof properties !== 'object' || Array.isArray(properties)) {
+        return {};
+    }
+    return properties;
+}
+function getMcpToolInputParameterNames(source) {
+    const propertyMap = getMcpToolInputPropertyMap(source);
+    const propertyNames = Object.keys(propertyMap);
+    if (propertyNames.length > 0) {
+        return propertyNames;
+    }
+    const schema = getInputSchemaObject(source);
+    if (!schema || !Array.isArray(schema.required)) {
+        return [];
+    }
+    return schema.required.filter((entry) => typeof entry === 'string');
+}
+function getMcpToolRequiredParameterNames(source) {
+    const schema = getInputSchemaObject(source);
+    if (!schema || !Array.isArray(schema.required)) {
+        return [];
+    }
+    return schema.required.filter((entry) => typeof entry === 'string');
+}
+function mcpToolAllowsAdditionalProperties(source) {
+    const schema = getInputSchemaObject(source);
+    if (!schema) {
+        return true;
+    }
+    return schema.additionalProperties !== false;
+}
+//# sourceMappingURL=mcpToolSchema.js.map

package/out/nornConfig.js

@@ -0,0 +1,132 @@
+"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.NORN_CONFIG_FILENAME = void 0;
+exports.findNearestConfigFile = findNearestConfigFile;
+exports.parseJsonFile = parseJsonFile;
+exports.isObjectRecord = isObjectRecord;
+exports.isStringRecord = isStringRecord;
+exports.loadNornConfig = loadNornConfig;
+exports.loadNornConfigSection = loadNornConfigSection;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+exports.NORN_CONFIG_FILENAME = 'norn.config.json';
+function getSearchDirectory(startPath) {
+    if (!startPath) {
+        return process.cwd();
+    }
+    const absolute = path.resolve(startPath);
+    try {
+        const stats = fs.statSync(absolute);
+        return stats.isDirectory() ? absolute : path.dirname(absolute);
+    }
+    catch {
+        return path.extname(absolute) ? path.dirname(absolute) : absolute;
+    }
+}
+function findNearestConfigFile(startPath, fileName) {
+    let currentDir = getSearchDirectory(startPath);
+    while (true) {
+        const candidate = path.join(currentDir, fileName);
+        if (fs.existsSync(candidate)) {
+            return candidate;
+        }
+        const parentDir = path.dirname(currentDir);
+        if (parentDir === currentDir) {
+            return undefined;
+        }
+        currentDir = parentDir;
+    }
+}
+function parseJsonFile(filePath, validator, label) {
+    let raw;
+    try {
+        raw = fs.readFileSync(filePath, 'utf-8');
+    }
+    catch (error) {
+        throw new Error(`Failed to read ${label}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch (error) {
+        throw new Error(`Invalid JSON in ${label}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    if (!validator(parsed)) {
+        throw new Error(`Invalid ${label} structure`);
+    }
+    return parsed;
+}
+function isObjectRecord(value) {
+    return !!value && typeof value === 'object' && !Array.isArray(value);
+}
+function isStringRecord(value) {
+    return isObjectRecord(value) && Object.values(value).every(entry => typeof entry === 'string');
+}
+function isKnownSection(value) {
+    return value === undefined || isObjectRecord(value);
+}
+function isNornProjectConfig(value) {
+    if (!isObjectRecord(value)) {
+        return false;
+    }
+    if (value.version !== 1) {
+        return false;
+    }
+    return isKnownSection(value.sql) && isKnownSection(value.mcp);
+}
+function loadNornConfig(startPath) {
+    const filePath = findNearestConfigFile(startPath, exports.NORN_CONFIG_FILENAME);
+    if (!filePath) {
+        throw new Error(`Could not find ${exports.NORN_CONFIG_FILENAME}`);
+    }
+    return {
+        filePath,
+        config: parseJsonFile(filePath, isNornProjectConfig, exports.NORN_CONFIG_FILENAME)
+    };
+}
+function loadNornConfigSection(startPath, sectionName, validator) {
+    const { filePath, config } = loadNornConfig(startPath);
+    const section = config[sectionName];
+    if (section === undefined) {
+        throw new Error(`Could not find ${sectionName} section in ${exports.NORN_CONFIG_FILENAME}`);
+    }
+    if (!validator(section)) {
+        throw new Error(`Invalid ${sectionName} section in ${exports.NORN_CONFIG_FILENAME}`);
+    }
+    return { filePath, section };
+}
+//# sourceMappingURL=nornConfig.js.map

package/out/nornHoverProvider.js

@@ -0,0 +1,124 @@
+"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.NornHoverProvider = void 0;
+const vscode = __importStar(require("vscode"));
+const environmentProvider_1 = require("./environmentProvider");
+const inlayHintResolver_1 = require("./inlayHintResolver");
+const environmentTemplates_1 = require("./environmentTemplates");
+const nornInlayHintsProvider_1 = require("./nornInlayHintsProvider");
+const nornapiHoverProvider_1 = require("./nornapiHoverProvider");
+/**
+ * Hover for `.norn`. On any `{{ref}}` token it returns one of:
+ *   - "Defined as <static value> in <scope> at line N" — when the ref is a file-local or
+ *     sequence-local var we can statically resolve.
+ *   - "Defined in <scope> at line N — runtime expression: <raw>" — when it's a runtime var
+ *     (response capture, request, run-sequence return).
+ *   - The standard env-scope hover (source + resolved value under active env) — when the
+ *     ref isn't a local var.
+ */
+class NornHoverProvider {
+    provideHover(document, position) {
+        try {
+            const filePath = document.uri.scheme === 'file' ? document.uri.fsPath : undefined;
+            if (!filePath) {
+                return undefined;
+            }
+            const lineText = document.lineAt(position.line).text;
+            const tokenMatch = (0, nornapiHoverProvider_1.findTemplateTokenAt)(lineText, position.character);
+            if (!tokenMatch) {
+                return undefined;
+            }
+            const parsed = (0, inlayHintResolver_1.parseInlayReference)(tokenMatch.referenceRaw);
+            if (!parsed) {
+                return undefined;
+            }
+            const config = (0, environmentProvider_1.loadEnvironmentConfig)(filePath);
+            const activeEnvironment = (0, environmentProvider_1.getActiveEnvironment)(filePath);
+            const index = (0, nornInlayHintsProvider_1.buildNornScopeIndex)(document.getText());
+            const inScope = (0, nornInlayHintsProvider_1.getInScopeDecls)(index, position.line);
+            const localDecl = inScope.find(decl => decl.name === parsed.name);
+            const hoverRange = new vscode.Range(new vscode.Position(position.line, tokenMatch.tokenStart), new vscode.Position(position.line, tokenMatch.tokenEnd));
+            if (localDecl && !parsed.envOnly) {
+                // Local var (sequence- or file-scope) takes precedence unless the reference
+                // explicitly opted into env scope via `{{$env.X}}`.
+                const markdown = renderLocalVarHover(localDecl, document, index, activeEnvironment, config);
+                return new vscode.Hover(markdown, hoverRange);
+            }
+            // No local match — fall through to the standard env-scope hover.
+            const markdown = (0, nornapiHoverProvider_1.renderTemplateReferenceHover)(parsed.name, config, activeEnvironment);
+            return new vscode.Hover(markdown, hoverRange);
+        }
+        catch {
+            return undefined;
+        }
+    }
+}
+exports.NornHoverProvider = NornHoverProvider;
+function renderLocalVarHover(decl, document, index, activeEnvironment, config) {
+    const lines = [`**\`${decl.name}\`**`];
+    const scopeLabel = decl.scope === 'sequence-local'
+        ? `\`sequence:${decl.sequenceName ?? '?'}\``
+        : '`file-local`';
+    lines.push(`Defined in ${scopeLabel} at line ${decl.lineNumber + 1}.`);
+    if (decl.isRuntime) {
+        lines.push(`Runtime expression: \`${decl.rawValue}\` — value is only known when the sequence runs.`);
+        return new vscode.MarkdownString(lines.join('\n\n'));
+    }
+    // Static value — show what it resolves to under the active env (in case the value itself
+    // contains {{...}} that reaches back into env scope).
+    const filePath = document.uri.scheme === 'file' ? document.uri.fsPath : undefined;
+    const envVariables = (filePath && config) ? (0, environmentProvider_1.getEnvironmentVariables)(filePath) : {};
+    const enclosing = (0, nornInlayHintsProvider_1.findEnclosingSequence)(index, decl.lineNumber);
+    void enclosing; // scope tracking is implicit in index; kept for future extension
+    const merged = (0, nornInlayHintsProvider_1.buildScopedVariablesAtLine)(envVariables, index, decl.lineNumber + 1);
+    const resolved = (0, environmentTemplates_1.resolveEnvironmentTemplateValue)(decl.name, merged, config?.secretNames ?? new Set());
+    if (resolved.errors.length === 0) {
+        if (resolved.secret) {
+            lines.push(`Resolves to a secret value.`);
+        }
+        else if (activeEnvironment) {
+            lines.push(`Under active env \`${activeEnvironment}\`, resolves to \`${resolved.value}\`.`);
+        }
+        else {
+            lines.push(`Value: \`${resolved.value}\`.`);
+        }
+    }
+    else {
+        lines.push(`Raw value: \`${decl.rawValue}\` (could not fully resolve — some references are missing or runtime-only).`);
+    }
+    return new vscode.MarkdownString(lines.join('\n\n'));
+}
+//# sourceMappingURL=nornHoverProvider.js.map