norn-cli 2.3.0 → 2.4.0

package/out/environmentProvider.js

@@ -0,0 +1,544 @@
+"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.onDidChangeActiveEnvironment = exports.parseEnvFile = void 0;
+exports.initializeEnvironmentMemento = initializeEnvironmentMemento;
+exports.findEnvFile = findEnvFile;
+exports.findEnvFileFromPath = findEnvFileFromPath;
+exports.loadEnvironmentConfig = loadEnvironmentConfig;
+exports.getEnvironmentSecretErrorDetails = getEnvironmentSecretErrorDetails;
+exports.getEnvironmentSecretErrors = getEnvironmentSecretErrors;
+exports.getEnvironmentSecretNames = getEnvironmentSecretNames;
+exports.promptForMissingEnvironmentSecretKeys = promptForMissingEnvironmentSecretKeys;
+exports.setEnvironmentSessionSecretKey = setEnvironmentSessionSecretKey;
+exports.clearEnvironmentSessionSecretKeys = clearEnvironmentSessionSecretKeys;
+exports.getActiveEnvironment = getActiveEnvironment;
+exports.setActiveEnvironment = setActiveEnvironment;
+exports.getEnvironmentVariables = getEnvironmentVariables;
+exports.getEnvironmentImportErrors = getEnvironmentImportErrors;
+exports.getEnvironmentImportErrorDetails = getEnvironmentImportErrorDetails;
+exports.getAvailableEnvironments = getAvailableEnvironments;
+exports.createStatusBarItem = createStatusBarItem;
+exports.refreshEnvironmentStatusBar = refreshEnvironmentStatusBar;
+exports.showEnvironmentPicker = showEnvironmentPicker;
+exports.disposeStatusBar = disposeStatusBar;
+exports.createCoverageStatusBarItem = createCoverageStatusBarItem;
+exports.refreshCoverageStatusBarContext = refreshCoverageStatusBarContext;
+exports.updateCoverageStatusBar = updateCoverageStatusBar;
+exports.getCoverageStatusBarItem = getCoverageStatusBarItem;
+const vscode = __importStar(require("vscode"));
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const environmentParser_1 = require("./environmentParser");
+const keyStore_1 = require("./secrets/keyStore");
+const environmentTemplates_1 = require("./environmentTemplates");
+var environmentParser_2 = require("./environmentParser");
+Object.defineProperty(exports, "parseEnvFile", { enumerable: true, get: function () { return environmentParser_2.parseEnvFile; } });
+/**
+ * Active env is tracked PER `.nornenv` file (keyed by absolute path). In a monorepo with
+ * multiple workspace folders each holding their own `.nornenv`, each remembers its own env.
+ * The whole map is persisted to a workspace-scoped memento so selections survive restart.
+ */
+const activeEnvironmentByEnvFile = new Map();
+let environmentMemento;
+const ACTIVE_ENV_MEMENTO_KEY = 'norn.activeEnvironmentByEnvFile';
+let statusBarItem;
+let coverageStatusBarItem;
+let hasCoverageData = false;
+const activeEnvironmentEmitter = new vscode.EventEmitter();
+exports.onDidChangeActiveEnvironment = activeEnvironmentEmitter.event;
+/**
+ * Loads persisted active-env selections from the workspace memento. Drops entries whose
+ * `.nornenv` file no longer exists so stale paths don't accumulate over time.
+ * Must be called once during `activate()` before any UI is shown.
+ */
+function initializeEnvironmentMemento(memento) {
+    environmentMemento = memento;
+    activeEnvironmentByEnvFile.clear();
+    const stored = memento.get(ACTIVE_ENV_MEMENTO_KEY, []);
+    let changed = false;
+    for (const [envFilePath, envName] of stored) {
+        if (fs.existsSync(envFilePath)) {
+            activeEnvironmentByEnvFile.set(envFilePath, envName);
+        }
+        else {
+            changed = true;
+        }
+    }
+    if (changed) {
+        persistActiveEnvironments();
+    }
+    updateStatusBar();
+}
+function persistActiveEnvironments() {
+    if (!environmentMemento) {
+        return;
+    }
+    void environmentMemento.update(ACTIVE_ENV_MEMENTO_KEY, Array.from(activeEnvironmentByEnvFile.entries()));
+}
+function getContextEnvFile() {
+    const activeEditor = vscode.window.activeTextEditor;
+    if (activeEditor && activeEditor.document.uri.scheme === 'file') {
+        return findEnvFileFromPath(activeEditor.document.uri.fsPath);
+    }
+    return findEnvFile();
+}
+function resolveEnvFilePath(pathOrSourceFile) {
+    if (!pathOrSourceFile) {
+        return getContextEnvFile();
+    }
+    const resolvedPath = path.resolve(pathOrSourceFile);
+    if (path.basename(resolvedPath) === environmentParser_1.ENV_FILENAME && fs.existsSync(resolvedPath)) {
+        return resolvedPath;
+    }
+    return findEnvFileFromPath(resolvedPath);
+}
+/**
+ * Finds the .nornenv file in the workspace
+ */
+function findEnvFile() {
+    const workspaceFolders = vscode.workspace.workspaceFolders;
+    if (!workspaceFolders) {
+        return undefined;
+    }
+    for (const folder of workspaceFolders) {
+        const envPath = path.join(folder.uri.fsPath, environmentParser_1.ENV_FILENAME);
+        if (fs.existsSync(envPath)) {
+            return envPath;
+        }
+    }
+    return undefined;
+}
+/**
+ * Finds .nornenv file relative to a specific file path (for CLI usage)
+ */
+function findEnvFileFromPath(filePath) {
+    return (0, environmentParser_1.findEnvFileFromPath)(filePath);
+}
+// parseEnvFile is now imported from ./environmentParser
+/**
+ * Reads and parses the resolved .nornenv file.
+ * Accepts either:
+ * - a path to a .nornenv file, or
+ * - a source file/directory path (it will resolve nearest .nornenv), or
+ * - undefined (uses current editor context/workspace fallback).
+ */
+function loadEnvironmentConfig(pathOrSourceFile) {
+    const filePath = resolveEnvFilePath(pathOrSourceFile);
+    if (!filePath || !fs.existsSync(filePath)) {
+        return undefined;
+    }
+    try {
+        const result = (0, environmentParser_1.loadAndResolveEnvFile)(filePath);
+        if (result.errors.length > 0 || result.secretErrors.length > 0) {
+            return undefined;
+        }
+        return result.config;
+    }
+    catch {
+        return undefined;
+    }
+}
+function getEnvironmentSecretErrorDetails(pathOrSourceFile) {
+    const filePath = resolveEnvFilePath(pathOrSourceFile);
+    if (!filePath || !fs.existsSync(filePath)) {
+        return [];
+    }
+    try {
+        const result = (0, environmentParser_1.loadAndResolveEnvFile)(filePath);
+        return result.secretErrors;
+    }
+    catch {
+        return [];
+    }
+}
+function getEnvironmentSecretErrors(pathOrSourceFile) {
+    return getEnvironmentSecretErrorDetails(pathOrSourceFile).map(e => e.message);
+}
+function getEnvironmentSecretNames(pathOrSourceFile) {
+    const filePath = resolveEnvFilePath(pathOrSourceFile);
+    if (!filePath || !fs.existsSync(filePath)) {
+        return new Set();
+    }
+    try {
+        const result = (0, environmentParser_1.loadAndResolveEnvFile)(filePath);
+        if (result.errors.length > 0) {
+            return new Set();
+        }
+        return new Set(result.config.secretNames);
+    }
+    catch {
+        return new Set();
+    }
+}
+function getUnlockableKids(errors) {
+    const kids = new Set();
+    for (const err of errors) {
+        if ((err.code === 'missing-key' || err.code === 'decrypt-failed') && err.kid) {
+            kids.add(err.kid);
+        }
+    }
+    return Array.from(kids.values()).sort();
+}
+async function promptForMissingEnvironmentSecretKeys(pathOrSourceFile) {
+    const filePath = resolveEnvFilePath(pathOrSourceFile);
+    if (!filePath || !fs.existsSync(filePath)) {
+        return true;
+    }
+    for (let attempt = 0; attempt < 5; attempt++) {
+        const secretErrors = getEnvironmentSecretErrorDetails(filePath);
+        const kids = getUnlockableKids(secretErrors);
+        if (kids.length === 0) {
+            return true;
+        }
+        for (const kid of kids) {
+            const value = await vscode.window.showInputBox({
+                prompt: `Enter shared key for kid '${kid}'`,
+                password: true,
+                ignoreFocusOut: true,
+                placeHolder: 'Paste shared key (it will be cached in the project .norn-cache)'
+            });
+            if (!value || value.trim() === '') {
+                return false;
+            }
+            (0, keyStore_1.saveSecretKeyToCache)(kid, value.trim(), filePath);
+        }
+    }
+    return getUnlockableKids(getEnvironmentSecretErrorDetails(filePath)).length === 0;
+}
+function setEnvironmentSessionSecretKey(kid, key) {
+    (0, keyStore_1.setSessionSecretKey)(kid, key);
+}
+function clearEnvironmentSessionSecretKeys() {
+    (0, keyStore_1.clearSessionSecretKeys)();
+}
+/**
+ * Returns the active environment for the `.nornenv` in scope for `pathOrSourceFile`,
+ * or for the current editor's context if omitted. Returns `undefined` when no `.nornenv`
+ * is in scope or when no env has been activated for that scope.
+ */
+function getActiveEnvironment(pathOrSourceFile) {
+    const envFilePath = resolveEnvFilePath(pathOrSourceFile);
+    if (!envFilePath) {
+        return undefined;
+    }
+    return activeEnvironmentByEnvFile.get(envFilePath);
+}
+/**
+ * Sets the active environment for the `.nornenv` in scope for `pathOrSourceFile`,
+ * or for the current editor's context if omitted. Persists the change to the workspace
+ * memento so it survives reload. Pass `undefined` to clear the selection for that scope.
+ */
+function setActiveEnvironment(envName, pathOrSourceFile) {
+    const envFilePath = resolveEnvFilePath(pathOrSourceFile);
+    if (!envFilePath) {
+        return;
+    }
+    const previous = activeEnvironmentByEnvFile.get(envFilePath);
+    if (envName === undefined) {
+        activeEnvironmentByEnvFile.delete(envFilePath);
+    }
+    else {
+        activeEnvironmentByEnvFile.set(envFilePath, envName);
+    }
+    persistActiveEnvironments();
+    updateStatusBar();
+    if (previous !== envName) {
+        activeEnvironmentEmitter.fire(envName);
+    }
+}
+/**
+ * Gets all variables for the current environment.
+ *
+ * Resolution: `common` ← ancestor templates/envs (left-to-right walk, right-most wins) ← self.
+ * Templates contribute their variables via `extends` but are never directly selectable.
+ *
+ * `envVariables` (passed to scope attachment) is the active env's **self-declared** vars only —
+ * not including ancestors. This keeps the runtime scope check meaningful (an env-section
+ * self-reference fires the scope diagnostic), while ancestor references are permitted
+ * because ancestor names appear in neither commonNames nor environmentNames.
+ */
+function getEnvironmentVariables(pathOrSourceFile) {
+    const config = loadEnvironmentConfig(pathOrSourceFile);
+    if (!config) {
+        return {};
+    }
+    let variables = { ...config.common };
+    let envVariables;
+    const activeForContext = getActiveEnvironment(pathOrSourceFile);
+    if (activeForContext) {
+        const env = config.environments.find(e => e.name === activeForContext);
+        if (env) {
+            envVariables = env.variables;
+            // resolveEffectiveEnvVariables returns common + ancestor chain + self merged
+            // with the correct precedence (right-most parent wins; self overrides all).
+            variables = (0, environmentParser_1.resolveEffectiveEnvVariables)(activeForContext, config);
+        }
+    }
+    return (0, environmentTemplates_1.attachEnvironmentTemplateScopes)(variables, config.common, envVariables);
+}
+/**
+ * Checks if the resolved .nornenv file has import errors.
+ * Returns the error messages, or an empty array if no errors.
+ */
+function getEnvironmentImportErrors(pathOrSourceFile) {
+    return getEnvironmentImportErrorDetails(pathOrSourceFile).map(e => e.message);
+}
+/**
+ * Returns detailed .nornenv import errors (message + file path + line).
+ */
+function getEnvironmentImportErrorDetails(pathOrSourceFile) {
+    const filePath = resolveEnvFilePath(pathOrSourceFile);
+    if (!filePath || !fs.existsSync(filePath)) {
+        return [];
+    }
+    try {
+        const result = (0, environmentParser_1.loadAndResolveEnvFile)(filePath);
+        return result.errors;
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Gets available environment names
+ */
+function getAvailableEnvironments(pathOrSourceFile) {
+    const filePath = resolveEnvFilePath(pathOrSourceFile);
+    if (!filePath || !fs.existsSync(filePath)) {
+        return [];
+    }
+    try {
+        const result = (0, environmentParser_1.loadAndResolveEnvFile)(filePath);
+        return result.config.environments.map(e => e.name);
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Creates and shows the status bar item
+ */
+function createStatusBarItem() {
+    statusBarItem = vscode.window.createStatusBarItem(vscode.StatusBarAlignment.Right, 100);
+    statusBarItem.command = 'norn.selectEnvironment';
+    updateStatusBar();
+    statusBarItem.show();
+    return statusBarItem;
+}
+/**
+ * Refreshes the status bar text based on current editor context.
+ */
+function refreshEnvironmentStatusBar() {
+    updateStatusBar();
+}
+/**
+ * Updates the status bar item text
+ */
+function updateStatusBar() {
+    if (!statusBarItem) {
+        return;
+    }
+    const envFile = getContextEnvFile();
+    if (!envFile) {
+        statusBarItem.text = '$(globe) Norn: No Env';
+        statusBarItem.tooltip = 'No .nornenv file found';
+        return;
+    }
+    const activeForContext = activeEnvironmentByEnvFile.get(envFile);
+    if (activeForContext) {
+        statusBarItem.text = `$(globe) Norn: ${activeForContext}`;
+        statusBarItem.tooltip = `Active environment: ${activeForContext}\nScope: ${envFile}\nClick to change`;
+    }
+    else {
+        statusBarItem.text = '$(globe) Norn: Select Env';
+        statusBarItem.tooltip = `No env selected for ${envFile}\nClick to select`;
+    }
+}
+/**
+ * Shows the environment picker
+ */
+async function showEnvironmentPicker(pathOrSourceFile) {
+    const envFilePath = pathOrSourceFile ? resolveEnvFilePath(pathOrSourceFile) : getContextEnvFile();
+    const environments = envFilePath ? getAvailableEnvironments(envFilePath) : [];
+    if (environments.length === 0) {
+        const createFile = await vscode.window.showInformationMessage('No .nornenv file found. Would you like to create one?', 'Create .nornenv', 'Cancel');
+        if (createFile === 'Create .nornenv') {
+            await createEnvFileTemplate();
+        }
+        return;
+    }
+    const activeForScope = envFilePath ? activeEnvironmentByEnvFile.get(envFilePath) : undefined;
+    const items = [
+        {
+            label: '$(circle-slash) None',
+            description: 'Use only common variables',
+            picked: !activeForScope
+        },
+        ...environments.map(env => ({
+            label: `$(server-environment) ${env}`,
+            description: env === activeForScope ? '(active)' : '',
+            picked: env === activeForScope
+        }))
+    ];
+    const selected = await vscode.window.showQuickPick(items, {
+        placeHolder: 'Select environment',
+        title: 'Norn Environment'
+    });
+    if (selected) {
+        if (selected.label.includes('None')) {
+            setActiveEnvironment(undefined, envFilePath);
+            vscode.window.showInformationMessage('Norn: Environment cleared');
+        }
+        else {
+            const envName = selected.label.replace('$(server-environment) ', '');
+            setActiveEnvironment(envName, envFilePath);
+            vscode.window.showInformationMessage(`Norn: Switched to "${envName}" environment`);
+        }
+    }
+}
+/**
+ * Creates a template .nornenv file
+ */
+async function createEnvFileTemplate() {
+    const workspaceFolders = vscode.workspace.workspaceFolders;
+    if (!workspaceFolders) {
+        vscode.window.showErrorMessage('No workspace folder open');
+        return;
+    }
+    const template = `# Norn Environment Configuration
+# Common variables are available in all environments
+
+var timeout = 30000
+var version = v1
+
+# Development environment
+[env:dev]
+var baseUrl = http://localhost:3000
+var apiKey = dev-key-123
+
+# Staging environment
+[env:staging]
+var baseUrl = https://staging.api.example.com
+var apiKey = staging-key-456
+
+# Production environment
+[env:prod]
+var baseUrl = https://api.example.com
+var apiKey = prod-key-789
+`;
+    const envPath = path.join(workspaceFolders[0].uri.fsPath, environmentParser_1.ENV_FILENAME);
+    fs.writeFileSync(envPath, template, 'utf-8');
+    const doc = await vscode.workspace.openTextDocument(envPath);
+    await vscode.window.showTextDocument(doc);
+    updateStatusBar();
+    vscode.window.showInformationMessage('Created .nornenv file');
+}
+/**
+ * Disposes the status bar item
+ */
+function disposeStatusBar() {
+    if (statusBarItem) {
+        statusBarItem.dispose();
+        statusBarItem = undefined;
+    }
+    if (coverageStatusBarItem) {
+        coverageStatusBarItem.dispose();
+        coverageStatusBarItem = undefined;
+    }
+    activeEnvironmentEmitter.dispose();
+}
+/**
+ * Creates the coverage status bar item
+ */
+function createCoverageStatusBarItem() {
+    coverageStatusBarItem = vscode.window.createStatusBarItem(vscode.StatusBarAlignment.Right, 99);
+    coverageStatusBarItem.command = 'norn.showCoverage';
+    coverageStatusBarItem.hide(); // Hidden until we know there's swagger
+    return coverageStatusBarItem;
+}
+function getActiveNornapiPath() {
+    const activeEditor = vscode.window.activeTextEditor;
+    if (!activeEditor) {
+        return undefined;
+    }
+    return activeEditor.document.languageId === 'nornapi'
+        ? activeEditor.document.uri.fsPath
+        : undefined;
+}
+/**
+ * Refresh coverage status bar command context for the current active editor.
+ */
+function refreshCoverageStatusBarContext() {
+    if (!coverageStatusBarItem || !hasCoverageData) {
+        return;
+    }
+    const activeNornapiPath = getActiveNornapiPath();
+    coverageStatusBarItem.command = {
+        command: 'norn.showCoverage',
+        title: 'Show Coverage',
+        arguments: activeNornapiPath ? [activeNornapiPath] : []
+    };
+    coverageStatusBarItem.text = '$(graph) Coverage';
+    coverageStatusBarItem.tooltip = activeNornapiPath
+        ? 'Show API coverage for this .nornapi file (includes this folder and subfolders only).'
+        : 'Show API coverage';
+    coverageStatusBarItem.show();
+}
+/**
+ * Updates the coverage status bar display
+ */
+function updateCoverageStatusBar(hasSwagger, percentage, total, covered) {
+    if (!coverageStatusBarItem) {
+        return;
+    }
+    if (!hasSwagger) {
+        hasCoverageData = false;
+        coverageStatusBarItem.hide();
+        return;
+    }
+    hasCoverageData = true;
+    void percentage;
+    void total;
+    void covered;
+    refreshCoverageStatusBarContext();
+}
+/**
+ * Get the coverage status bar item (for external updates)
+ */
+function getCoverageStatusBarItem() {
+    return coverageStatusBarItem;
+}
+//# sourceMappingURL=environmentProvider.js.map

package/out/environmentTemplates.js

@@ -0,0 +1,146 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.attachEnvironmentTemplateScopes = attachEnvironmentTemplateScopes;
+exports.hasEnvironmentTemplate = hasEnvironmentTemplate;
+exports.resolveEnvironmentTemplateValue = resolveEnvironmentTemplateValue;
+exports.collectResolvedEnvironmentSecretValues = collectResolvedEnvironmentSecretValues;
+const TEMPLATE_TOKEN_REGEX = /\{\{([^{}]+)\}\}/g;
+const ENV_REFERENCE_REGEX = /^(?:\$env\.)?([a-zA-Z_][a-zA-Z0-9_]*)$/;
+const ENV_TEMPLATE_SCOPES_KEY = '$nornEnvTemplateScopes';
+function attachEnvironmentTemplateScopes(variables, commonVariables, environmentVariables) {
+    Object.defineProperty(variables, ENV_TEMPLATE_SCOPES_KEY, {
+        value: {
+            commonNames: new Set(Object.keys(commonVariables)),
+            environmentNames: new Set(Object.keys(environmentVariables ?? {}))
+        },
+        enumerable: false,
+        configurable: true,
+        writable: false
+    });
+    return variables;
+}
+function getEnvironmentTemplateScopes(variables) {
+    const value = variables[ENV_TEMPLATE_SCOPES_KEY];
+    if (!value || typeof value !== 'object') {
+        return undefined;
+    }
+    const candidate = value;
+    if (!(candidate.commonNames instanceof Set) || !(candidate.environmentNames instanceof Set)) {
+        return undefined;
+    }
+    return candidate;
+}
+function valueToTemplateString(value) {
+    if (value === undefined || value === null) {
+        return '';
+    }
+    if (typeof value === 'object') {
+        return JSON.stringify(value);
+    }
+    return String(value);
+}
+function parseTemplateReference(rawReference) {
+    const trimmed = rawReference.trim();
+    const match = trimmed.match(ENV_REFERENCE_REGEX);
+    return match?.[1];
+}
+function hasEnvironmentTemplate(value) {
+    return typeof value === 'string' && /\{\{[^{}]+\}\}/.test(value);
+}
+function resolveEnvironmentTemplateValue(variableName, variables, secretNames = new Set()) {
+    const resolving = new Set();
+    const cache = new Map();
+    const scopes = getEnvironmentTemplateScopes(variables);
+    const resolveVariable = (name) => {
+        const cached = cache.get(name);
+        if (cached) {
+            return cached;
+        }
+        if (resolving.has(name)) {
+            const cycle = [...resolving, name].join(' -> ');
+            return {
+                value: `{{${name}}}`,
+                secret: secretNames.has(name),
+                dependencies: new Set([name]),
+                errors: [{
+                        kind: 'cycle',
+                        variableName: name,
+                        reference: name,
+                        message: `Circular .nornenv template reference detected: ${cycle}`
+                    }]
+            };
+        }
+        if (!Object.prototype.hasOwnProperty.call(variables, name)) {
+            return {
+                value: `{{${name}}}`,
+                secret: false,
+                dependencies: new Set([name]),
+                errors: [{
+                        kind: 'unresolved',
+                        variableName: name,
+                        reference: name,
+                        message: `.nornenv template reference '${name}' was not found in the active environment.`
+                    }]
+            };
+        }
+        resolving.add(name);
+        const rawValue = valueToTemplateString(variables[name]);
+        const dependencies = new Set();
+        const errors = [];
+        let secret = secretNames.has(name);
+        const value = rawValue.replace(TEMPLATE_TOKEN_REGEX, (token, rawReference) => {
+            const referenceName = parseTemplateReference(rawReference);
+            if (!referenceName) {
+                errors.push({
+                    kind: 'unsupported',
+                    variableName: name,
+                    reference: rawReference.trim(),
+                    message: `.nornenv template reference '${rawReference.trim()}' is not supported. Use {{name}} or {{$env.name}}.`
+                });
+                return token;
+            }
+            const resolved = resolveVariable(referenceName);
+            dependencies.add(referenceName);
+            for (const dependency of resolved.dependencies) {
+                dependencies.add(dependency);
+            }
+            if (scopes?.environmentNames.has(name) && scopes.environmentNames.has(referenceName)) {
+                errors.push({
+                    kind: 'scope',
+                    variableName: name,
+                    reference: referenceName,
+                    message: `.nornenv template reference '${referenceName}' is not in scope. Values inside [env:...] sections can reference common variables and inherited ancestor variables only.`
+                });
+            }
+            if (resolved.secret) {
+                secret = true;
+            }
+            errors.push(...resolved.errors);
+            return resolved.value;
+        });
+        resolving.delete(name);
+        const resolution = {
+            value,
+            secret,
+            dependencies,
+            errors
+        };
+        cache.set(name, resolution);
+        return resolution;
+    };
+    return resolveVariable(variableName);
+}
+function collectResolvedEnvironmentSecretValues(variables, secretNames) {
+    const values = new Map();
+    for (const name of secretNames) {
+        if (!Object.prototype.hasOwnProperty.call(variables, name)) {
+            continue;
+        }
+        const resolved = resolveEnvironmentTemplateValue(name, variables, secretNames);
+        if (resolved.errors.length === 0) {
+            values.set(name, resolved.value);
+        }
+    }
+    return values;
+}
+//# sourceMappingURL=environmentTemplates.js.map