@powerlines/plugin-env 0.15.2 → 0.15.4

package/dist/index.mjs

@@ -1,33 +1,653 @@
-import { type_exports } from "./deepkit/src/vendor/type.mjs";
-import src_default$1 from "./plugin-alloy/src/index.mjs";
-import src_default$2 from "./plugin-automd/src/index.mjs";
-import src_default$3 from "./plugin-babel/src/index.mjs";
-import { BaseEnv, BaseSecrets, createEnvReflection, createSecretsReflection, mergeEnvReflections, mergeSecretsReflections, reflectEnv, reflectSecrets } from "./helpers/reflect.mjs";
-import { getEnvDefaultTypeDefinition, getEnvReflectionsPath, getEnvTypeReflectionsPath, getSecretsDefaultTypeDefinition, readEnvReflection, readEnvTypeReflection, readSecretsReflection, resolveRuntimeTypeFile, writeEnvReflection, writeEnvReflectionSync, writeEnvTypeReflection } from "./helpers/persistence.mjs";
-import { envBabelPlugin } from "./babel/plugin.mjs";
-import { formatEnvField, removeEnvPrefix } from "./helpers/source-file-env.mjs";
-import { loadEnv, loadEnvFromContext } from "./helpers/load.mjs";
-import { createReflectionResource } from "./helpers/create-reflection-resource.mjs";
-import { EnvBuiltin, EnvTypeDefinition } from "./components/env.mjs";
-import { env } from "./helpers/automd-generator.mjs";
-import "./babel/index.mjs";
-import { EnvDocs } from "./components/docs.mjs";
-import "./components/index.mjs";
-import { createTemplateReflection } from "./helpers/template-helpers.mjs";
-import "./helpers/index.mjs";
-import { createComponent } from "@alloy-js/core/jsx-runtime";
+import { A as reflectSecrets, C as BaseEnv, D as mergeEnvReflections, E as createSecretsReflection, M as convertFromCapnp, N as PowerlinesContext, O as mergeSecretsReflections, S as writeEnvTypeReflection, T as createEnvReflection, _ as readEnvTypeReflection, a as removeEnvPrefix, b as writeEnvReflection, f as getEnvDefaultTypeDefinition, g as readEnvReflection, h as getSecretsDefaultTypeDefinition, i as formatEnvField, j as SerializedTypes, k as reflectEnv, m as getEnvTypeReflectionsPath, n as loadEnv, p as getEnvReflectionsPath, r as loadEnvFromContext, t as createReflectionResource, v as readSecretsReflection, w as BaseSecrets, x as writeEnvReflectionSync, y as resolveRuntimeTypeFile } from "./create-reflection-resource-BNYxBgW2.mjs";
+import { n as EnvTypeDefinition, r as stringifyDefaultValue, t as EnvBuiltin } from "./env-IQvgnabX.mjs";
+import { t as EnvDocs } from "./docs-B66b9li3.mjs";
+import "./components-CNIQFfeK.mjs";
+import "./plugin-D3B5E_Hg.mjs";
+import "./runtime-azNoeKr-.mjs";
+import "./types-DwElXV6q.mjs";
+import { createComponent, mergeProps } from "@alloy-js/core/jsx-runtime";
+import { ReflectionClass, ReflectionKind, deserializeType, resolveClassType, stringifyType } from "@powerlines/deepkit/vendor/type";
+import { Output, Show, computed, ref, renderAsync, splitProps, traverseOutput } from "@alloy-js/core";
+import alloy from "@alloy-js/rollup-plugin";
+import { StormJSON } from "@stryke/json/storm-json";
+import { replacePath } from "@stryke/path/replace";
 import { toArray } from "@stryke/convert/to-array";
+import { isDirectory } from "@stryke/fs/is-file";
+import { listFiles } from "@stryke/fs/list-files";
+import { appendPath } from "@stryke/path/append";
+import { isAbsolutePath } from "@stryke/path/is-type";
+import { joinPaths } from "@stryke/path/join-paths";
+import { defineGenerator, loadConfig, resolveConfig, transform } from "automd";
+import { loadConfig as loadConfig$1 } from "c12";
 import defu from "defu";
+import toc from "markdown-toc";
+import { transformAsync } from "@babel/core";
 import { LogLevelLabel } from "@storm-software/config-tools/types";
+import { findFileExtension, findFileExtensionSafe } from "@stryke/path/file-path-fns";
 import { isParentPath } from "@stryke/path/is-parent-path";
+import { isSetObject } from "@stryke/type-checks/is-set-object";
+import { isFunction } from "@stryke/type-checks/is-function";
+import "@stryke/type-checks/is-object";
+import { isSetString } from "@stryke/type-checks/is-set-string";
+import chalk from "chalk";
+import _generate from "@babel/generator";
+import "@babel/parser";
+import { declare } from "@babel/helper-plugin-utils";
+import "@storm-software/config-tools/logger";
+import "@storm-software/config-tools/utilities/colors";
+import "@stryke/helpers/noop";
+import { kebabCase } from "@stryke/string-format/kebab-case";
 import { titleCase } from "@stryke/string-format/title-case";
+import * as t from "@babel/types";
+import { isString } from "@stryke/type-checks/is-string";
 import { parseTypeDefinition } from "@stryke/convert/parse-type-definition";
 import { ENV_PREFIXES } from "@stryke/env/types";
 import { existsSync } from "@stryke/fs/exists";
 import { createDirectory } from "@stryke/fs/helpers";
-import { joinPaths } from "@stryke/path/join";
+import { joinPaths as joinPaths$1 } from "@stryke/path/join";
 import { constantCase } from "@stryke/string-format/constant-case";
+import * as capnp from "@stryke/capnp";
+import { readFileBufferSync } from "@stryke/fs/buffer";
+import { existsSync as existsSync$1 } from "node:fs";
 
+//#region ../plugin-alloy/src/core/components/output.tsx
+/**
+* Output component for rendering the Powerlines plugin's output files via templates.
+*/
+function Output$1(props) {
+	const [{ children, context, meta, basePath }, rest] = splitProps(props, [
+		"children",
+		"context",
+		"meta",
+		"basePath"
+	]);
+	const contextRef = ref(context);
+	const metaRef = ref(meta ?? {});
+	const basePathRef = computed(() => basePath ? replacePath(basePath, contextRef.value.workspaceConfig.workspaceRoot) : contextRef.value.workspaceConfig.workspaceRoot);
+	return createComponent(Output, mergeProps(rest, {
+		get basePath() {
+			return basePathRef.value;
+		},
+		get children() {
+			return createComponent(PowerlinesContext.Provider, {
+				value: {
+					ref: contextRef,
+					meta: metaRef
+				},
+				get children() {
+					return createComponent(Show, {
+						get when() {
+							return Boolean(contextRef.value);
+						},
+						children
+					});
+				}
+			});
+		}
+	}));
+}
+
+//#endregion
+//#region ../plugin-alloy/src/index.tsx
+/**
+* Alloy-js plugin for Powerlines.
+*
+* @param options - The Alloy-js plugin user configuration options.
+* @returns A Powerlines plugin that integrates Alloy-js transformations.
+*/
+const plugin$3 = (options = {}) => {
+	return [{
+		name: "alloy:config",
+		config() {
+			return {
+				alloy: {
+					typescript: true,
+					...options
+				},
+				build: {
+					inputOptions: { transform: { jsx: {
+						runtime: "classic",
+						pragma: "Alloy.createElement",
+						importSource: "@alloy-js/core"
+					} } },
+					plugins: [alloy()]
+				}
+			};
+		},
+		async configResolved() {
+			if (this.tsconfig.tsconfigJson.compilerOptions?.jsx !== "preserve" || this.tsconfig.tsconfigJson.compilerOptions?.jsxImportSource !== "@alloy-js/core") {
+				this.tsconfig.tsconfigJson.compilerOptions ??= {};
+				if (this.tsconfig.tsconfigJson.compilerOptions.jsx !== "preserve") this.tsconfig.tsconfigJson.compilerOptions.jsx = "preserve";
+				if (this.tsconfig.tsconfigJson.compilerOptions.jsxImportSource !== "@alloy-js/core") this.tsconfig.tsconfigJson.compilerOptions.jsxImportSource = "@alloy-js/core";
+				await this.fs.write(this.tsconfig.tsconfigFilePath, StormJSON.stringify(this.tsconfig.tsconfigJson));
+			}
+			this.dependencies["@alloy-js/core"] = "^0.22.0";
+			if (this.config.alloy?.typescript !== false) this.dependencies["@alloy-js/typescript"] = "^0.22.0";
+			if (this.config.alloy?.json === true) this.dependencies["@alloy-js/json"] = "^0.22.0";
+			if (this.config.alloy?.markdown === true) this.dependencies["@alloy-js/markdown"] = "^0.22.0";
+		}
+	}, {
+		name: "alloy:update-context",
+		configResolved: {
+			order: "pre",
+			async handler() {
+				this.render = async (children) => {
+					const _self$ = this;
+					const meta = {};
+					await traverseOutput(await renderAsync(createComponent(Output$1, {
+						context: _self$,
+						meta,
+						get basePath() {
+							return _self$.workspaceConfig.workspaceRoot;
+						},
+						children
+					})), {
+						visitDirectory: (directory) => {
+							if (this.fs.existsSync(directory.path)) return;
+							this.fs.mkdirSync(directory.path);
+						},
+						visitFile: (file) => {
+							if ("contents" in file) {
+								const metadata = meta[file.path] ?? {};
+								if (metadata.kind === "builtin") {
+									if (!metadata.id) throw new Error(`Built-in file "${file.path}" is missing its ID in the render metadata.`);
+									this.emitBuiltinSync(file.contents, metadata.id, file.path, {
+										skipFormat: metadata.skipFormat,
+										storage: metadata.storage
+									});
+								} else if (metadata.kind === "entry") this.emitEntrySync(file.contents, file.path, {
+									skipFormat: metadata.skipFormat,
+									storage: metadata.storage,
+									...metadata.typeDefinition ?? {}
+								});
+								else this.emitSync(file.contents, file.path, metadata);
+							} else this.fs.copySync(file.sourcePath, file.path);
+						}
+					});
+				};
+			}
+		}
+	}];
+};
+var src_default$1 = plugin$3;
+
+//#endregion
+//#region ../plugin-automd/src/index.ts
+/**
+* AutoMD Plugin
+*
+* @remarks
+* A Powerlines plugin to use the AutoMD markdown transformer during the prepare task.
+*
+* @see https://automd.unjs.io/
+*
+* @param options - The plugin options.
+* @returns A Powerlines plugin instance.
+*/
+const plugin$2 = (options = {}) => {
+	return {
+		name: "automd",
+		async config() {
+			const config = await loadConfig(joinPaths(this.workspaceConfig.workspaceRoot, this.config.projectRoot), options);
+			if (!config.prefix || !Array.isArray(config.prefix)) config.prefix = toArray(config.prefix ?? []);
+			if (!config.prefix.includes("automd")) config.prefix.push("automd");
+			if (!config.prefix.includes("powerlines")) config.prefix.push("powerlines");
+			return { automd: defu(config ?? {}, {
+				configFile: options.configFile,
+				allowIssues: true,
+				dir: this.config.projectRoot,
+				watch: false,
+				input: "README.md",
+				toc: {
+					maxDepth: 6,
+					bullets: "-"
+				}
+			}) };
+		},
+		async configResolved() {
+			if (this.config.framework && !toArray(this.config.automd.prefix).includes(this.config.framework)) this.config.automd.prefix = toArray(this.config.automd.prefix).concat(this.config.framework);
+			if (this.config.automd.configFile) {
+				const { config } = await loadConfig$1({
+					cwd: this.config.automd.dir,
+					configFile: this.config.automd.configFile,
+					defaults: {
+						ignore: [
+							"**/node_modules",
+							"**/dist",
+							"**/.*"
+						],
+						dir: this.config.automd.dir
+					}
+				});
+				this.config.automd = resolveConfig(defu(this.config.automd, {
+					...config,
+					prefix: toArray(config.prefix ?? [])
+				}));
+			}
+			this.config.automd.input = (await Promise.all(toArray(this.config.automd.input).map(async (input) => {
+				if (input.includes("*")) return listFiles(isAbsolutePath(input) ? input : appendPath(input, this.config.projectRoot), { ignore: this.config.automd.ignore });
+				return isAbsolutePath(input) ? input : appendPath(input, this.config.projectRoot);
+			}))).flat();
+			if (this.config.automd.output && !isAbsolutePath(this.config.automd.output)) this.config.automd.output = appendPath(this.config.automd.output, this.config.projectRoot);
+			this.config.automd.generators ??= {};
+			if (this.config.automd.toc !== false) this.config.automd.generators.toc ??= {
+				name: "toc",
+				generate: (ctx) => {
+					const opts = this.config.automd.toc ?? {};
+					return { contents: toc(ctx.block.md, {
+						...opts,
+						maxdepth: opts.maxDepth,
+						first1: opts.firstH1
+					}).content };
+				}
+			};
+		},
+		async docs() {
+			await Promise.all(toArray(this.config.automd.input).map(async (input) => {
+				const contents = await this.fs.read(input);
+				if (contents) {
+					const result = await transform(contents, this.config.automd);
+					if (result.hasIssues && this.config.automd.allowIssues === false) throw new Error(`AutoMD found issues in file "${input}". Please resolve the issues or set \`allowIssues\` to true in the plugin configuration to ignore them.`);
+					if (result.hasChanged) await this.fs.write(appendPath(this.config.automd.output ? isDirectory(this.config.automd.output) ? replacePath(input, this.config.automd.output) : this.config.automd.output : input, this.config.projectRoot), result.contents);
+				}
+			}));
+		}
+	};
+};
+var src_default$2 = plugin$2;
+
+//#endregion
+//#region ../plugin-babel/src/helpers/filters.ts
+function getPluginName(plugin$4) {
+	return isSetString(plugin$4) ? plugin$4 : Array.isArray(plugin$4) && plugin$4.length > 0 ? getPluginName(plugin$4[0]) : plugin$4.$$name || plugin$4.name ? plugin$4.$$name || plugin$4.name : void 0;
+}
+/**
+* Check if a Babel plugin is a duplicate of another plugin in the list.
+*
+* @param plugins - The list of existing Babel plugins.
+* @param plugin - The Babel plugin to check for duplicates.
+* @returns True if the plugin is a duplicate, false otherwise.
+*/
+function isDuplicatePlugin(plugins, plugin$4) {
+	return !!(getPluginName(plugin$4) && plugins.some((existing) => Array.isArray(existing) && getPluginName(existing[0]) === getPluginName(plugin$4)));
+}
+
+//#endregion
+//#region ../plugin-babel/src/helpers/options.ts
+function resolvePluginFunction(context, plugin$4) {
+	try {
+		return Array.isArray(plugin$4) && plugin$4.length > 0 && plugin$4[0] ? isFunction(plugin$4[0]) ? plugin$4[0](context) : plugin$4[0] : isFunction(plugin$4) ? plugin$4(context) : plugin$4;
+	} catch {
+		return plugin$4[0];
+	}
+}
+/**
+* Resolve the [Babel](https://babeljs.io/) plugin.
+*
+* @param context - The context for the transformation.
+* @param code - The code to be transformed.
+* @param id - The ID of the source file.
+* @param plugin - The Babel plugin to resolve.
+* @returns The resolved Babel plugin options, or undefined if the plugin is filtered out.
+*/
+function resolveBabelPlugin(context, code$1, id, plugin$4) {
+	if (Array.isArray(plugin$4) && plugin$4.length > 0 && plugin$4[0]) {
+		if (plugin$4.length > 2 && plugin$4[2] && isFunction(plugin$4[2]) && !plugin$4[2](code$1, id)) {
+			context.log(LogLevelLabel.TRACE, `Skipping filtered Babel plugin ${chalk.bold.cyanBright(getPluginName(plugin$4) || "unnamed")} for ${id}`);
+			return;
+		}
+		return plugin$4.length > 2 ? [
+			resolvePluginFunction(context, plugin$4),
+			plugin$4[1],
+			plugin$4[2]
+		] : [
+			resolvePluginFunction(context, plugin$4),
+			plugin$4[1],
+			null
+		];
+	}
+	return [
+		resolvePluginFunction(context, plugin$4),
+		{},
+		null
+	];
+}
+
+//#endregion
+//#region ../plugin-babel/src/helpers/ast-utils.ts
+let generate = _generate;
+if ("default" in generate) generate = generate.default;
+
+//#endregion
+//#region ../powerlines/src/lib/logger.ts
+const BADGE_COLORS = [
+	"#00A0DD",
+	"#6FCE4E",
+	"#FBBF24",
+	"#F43F5E",
+	"#3B82F6",
+	"#A855F7",
+	"#469592",
+	"#288EDF",
+	"#D8B4FE",
+	"#10B981",
+	"#EF4444",
+	"#F0EC56",
+	"#F472B6",
+	"#22D3EE",
+	"#EAB308",
+	"#84CC16",
+	"#F87171",
+	"#0EA5E9",
+	"#D946EF",
+	"#FACC15",
+	"#34D399",
+	"#8B5CF6"
+];
+const extendLog = (logFn, name) => {
+	return (type, ...args) => logFn(type, ` ${chalk.inverse.hex(BADGE_COLORS[name.split("").map((char) => char.charCodeAt(0)).reduce((ret, charCode) => ret + charCode, 0) % BADGE_COLORS.length] || BADGE_COLORS[0])(` ${titleCase(name)} `)}  ${args.join(" ")} `);
+};
+
+//#endregion
+//#region ../plugin-babel/src/helpers/create-plugin.ts
+/**
+* Create a Babel plugin using the provided builder function.
+*
+* @param name - The name of the plugin.
+* @param builder - The builder function that defines the plugin behavior.
+* @returns A Babel plugin declaration.
+*/
+function createBabelPlugin(name, builder) {
+	const plugin$4 = (context) => {
+		return declare((api, options, dirname) => {
+			api.cache.using(() => context.meta.checksum);
+			api.assertVersion("^7.0.0-0");
+			const log = extendLog(context.log, name);
+			log(LogLevelLabel.TRACE, `Initializing the ${chalk.bold.cyanBright(name)} Babel plugin`);
+			const result = builder({
+				log,
+				name,
+				api,
+				options,
+				context,
+				dirname
+			});
+			result.name = name;
+			log(LogLevelLabel.TRACE, `Completed initialization of the ${chalk.bold.cyanBright(name)} Babel plugin`);
+			return result;
+		});
+	};
+	plugin$4.$$name = name;
+	return plugin$4;
+}
+
+//#endregion
+//#region ../plugin-babel/src/helpers/module-helpers.ts
+/**
+* Adds an import to the program if it doesn't already exist.
+*
+* @param path - The current NodePath in the AST.
+* @param specifier - The import specifier.
+*/
+function addImport(path, specifier) {
+	addImportsToProgram(path.scope.getProgramParent().path, specifier);
+}
+function isNonNamespacedImport(importDeclPath) {
+	return importDeclPath.get("specifiers").filter(Boolean).every((specifier) => specifier?.isImportSpecifier()) && importDeclPath.node.importKind !== "type" && importDeclPath.node.importKind !== "typeof";
+}
+function getExistingImports(program) {
+	const existingImports = /* @__PURE__ */ new Map();
+	program.traverse({ ImportDeclaration(path) {
+		if (isNonNamespacedImport(path)) existingImports.set(path.node.source.value, path);
+	} });
+	return existingImports;
+}
+function addImportsToProgram(path, specifier) {
+	/**
+	* If an existing import of this module exists (ie \`import \{ ... \} from
+	* '<moduleName>'\`), inject new imported specifiers into the list of
+	* destructured variables.
+	*/
+	if (!getExistingImports(path).get(specifier.module)) path.unshiftContainer("body", t.importDeclaration([t.importSpecifier(t.identifier(specifier.name || specifier.imported), t.identifier(specifier.imported))], t.stringLiteral(specifier.module)));
+}
+
+//#endregion
+//#region ../plugin-babel/src/index.ts
+/**
+* Babel plugin for Powerlines.
+*
+* @param options - The Babel plugin user configuration options.
+* @returns A Powerlines plugin that integrates Babel transformations.
+*/
+const plugin$1 = (options = {}) => {
+	return {
+		name: "babel",
+		config() {
+			if (!isSetObject(options)) return;
+			return { transform: { babel: options } };
+		},
+		configResolved: {
+			order: "pre",
+			handler() {
+				this.devDependencies["@babel/core"] = "^7.28.4";
+				this.config.transform.babel = defu(this.config.transform.babel ?? {}, {
+					plugins: [],
+					presets: []
+				});
+			}
+		},
+		async transform(code$1, id) {
+			if (isParentPath(id, this.powerlinesPath) || code$1.includes("/* @storm-ignore */") || code$1.includes("/* @storm-disable */")) {
+				this.log(LogLevelLabel.TRACE, `Skipping Babel transformation for: ${id}`);
+				return {
+					code: code$1,
+					id
+				};
+			}
+			this.log(LogLevelLabel.TRACE, `Babel transforming file: ${id}`);
+			const plugins = this.config.transform.babel.plugins.map((plugin$4) => resolveBabelPlugin(this, code$1, id, plugin$4)).filter((plugin$4, _, arr) => plugin$4 && !isDuplicatePlugin(arr, plugin$4));
+			const presets = this.config.transform.babel.presets.map((preset) => resolveBabelPlugin(this, code$1, id, preset)).filter((preset, _, arr) => preset && !isDuplicatePlugin(arr, preset));
+			if (Array.isArray(plugins) && plugins.length === 0 && Array.isArray(presets) && presets.length === 0) return {
+				code: code$1,
+				id
+			};
+			if ([
+				"ts",
+				"cts",
+				"mts",
+				"tsx"
+			].includes(findFileExtensionSafe(id)) && !isDuplicatePlugin(plugins, "@babel/plugin-syntax-typescript") && !isDuplicatePlugin(presets, "@babel/preset-typescript")) plugins.unshift(["@babel/plugin-syntax-typescript", { isTSX: findFileExtension(id) === ".tsx" }]);
+			const result = await transformAsync(code$1, {
+				highlightCode: true,
+				code: true,
+				ast: false,
+				cloneInputAst: false,
+				comments: true,
+				sourceType: "module",
+				configFile: false,
+				babelrc: false,
+				envName: this.config.mode,
+				caller: { name: this.config.framework },
+				...this.config.transform.babel ?? {},
+				filename: id,
+				plugins: plugins.map((plugin$4) => {
+					return Array.isArray(plugin$4) && plugin$4.length >= 2 ? [plugin$4[0], defu(plugin$4.length > 1 && plugin$4[1] ? plugin$4[1] : {}, { options })] : plugin$4;
+				}).filter(Boolean),
+				presets: presets.map((preset) => {
+					return Array.isArray(preset) && preset.length >= 2 ? [preset[0], defu(preset.length > 1 && preset[1] ? preset[1] : {}, { options })] : preset;
+				}).filter(Boolean)
+			});
+			if (!result?.code) throw new Error(`Powerlines - Babel plugin failed to compile ${id}`);
+			return {
+				code: result.code,
+				id
+			};
+		}
+	};
+};
+var src_default$3 = plugin$1;
+
+//#endregion
+//#region src/babel/plugin.ts
+const envBabelPlugin = createBabelPlugin("env", ({ log, context }) => {
+	function extractEnv(node, pass, isInjectable = false) {
+		const envTypesAliasProperties = context.env.types.env?.getProperties().filter((prop) => prop.getAlias().length > 0);
+		if (node.name) {
+			const prefix = context.config.env.prefix.find((pre) => node.name && node.name.startsWith(pre) && (context.env.types.env?.hasProperty(node.name.replace(`${pre}_`, "")) || envTypesAliasProperties.some((prop) => prop.getAlias().includes(node.name.replace(`${pre}_`, "")))));
+			let name = node.name;
+			if (prefix) name = node.name.replace(`${prefix}_`, "");
+			log(LogLevelLabel.TRACE, `Environment variable ${name} found in ${pass.filename || "unknown file"}.`);
+			if (context.env.types.env?.hasProperty(name) || envTypesAliasProperties.some((prop) => prop.getAlias().includes(name))) {
+				const envProperty = context.env.types.env.hasProperty(name) ? context.env.types.env.getProperty(name) : envTypesAliasProperties.find((prop) => prop.getAlias().includes(name));
+				if (!envProperty || envProperty.isIgnored()) return;
+				if (!context.env.used.env.hasProperty(name)) context.env.used.env.addProperty(envProperty.property);
+				if (context.config.env.inject && isInjectable) {
+					let value = context.env.parsed?.[name];
+					if (value === void 0) {
+						const prefix$1 = context.config.env.prefix.find((pre) => {
+							return context.env.parsed[`${pre.replace(/_$/g, "")}_${name}`];
+						});
+						if (prefix$1) value = context.env.parsed[`${prefix$1.replace(/_$/g, "")}_${name}`];
+					}
+					value ??= envProperty.getDefaultValue();
+					if (envProperty.isValueRequired() && value === void 0) throw new Error(`Environment variable \`${name}\` is not defined in the .env configuration files`);
+					return stringifyDefaultValue(envProperty, value);
+				}
+			} else throw new Error(`The "${name}" environment variable is not defined in the \`env\` type definition, but is used in the source code file ${pass.filename ? pass.filename : "unknown"}.
+
+          The following environment configuration names are defined in the \`env\` type definition: \n${context.env.types.env?.getPropertyNames().sort((a, b) => String(a).localeCompare(String(b))).map((typeDef) => ` - ${String(typeDef)} ${envTypesAliasProperties.some((prop) => prop.getNameAsString() === String(typeDef) && prop.getAlias().length > 0) ? `(Alias: ${envTypesAliasProperties?.find((prop) => prop.getNameAsString() === String(typeDef))?.getAlias().join(", ")})` : ""}`).join("\n")} \n\nUsing the following env prefix: \n${context.config.env.prefix.map((prefix$1) => ` - ${prefix$1}`).join("\n")} \n\nPlease check your \`env\` configuration option. If you are using a custom dotenv type definition, please make sure that the configuration names match the ones in the code. \n\n`);
+		}
+	}
+	return {
+		visitor: { MemberExpression(path, pass) {
+			if (path.get("object")?.get("property")?.isIdentifier({ name: "env" }) && path.get("object")?.get("object")?.isIdentifier({ name: "$storm" }) && path.get("property")?.isIdentifier()) {
+				const identifier = path.get("property")?.node;
+				extractEnv(identifier, pass, false);
+				path.replaceWithSourceString(`env.${identifier.name}`);
+				addImport(path, {
+					module: "storm:env",
+					name: "env",
+					imported: "env"
+				});
+			} else if (path.get("object")?.get("property")?.isIdentifier({ name: "env" }) && path.get("object")?.get("object")?.isCallExpression({ callee: {
+				name: "useStorm",
+				type: "Identifier"
+			} }) && path.get("property")?.isIdentifier()) {
+				const identifier = path.get("property")?.node;
+				extractEnv(identifier, pass, false);
+				path.replaceWithSourceString(`env.${identifier.name}`);
+				addImport(path, {
+					module: "storm:env",
+					name: "env",
+					imported: "env"
+				});
+			} else if (path.get("object")?.get("property")?.isIdentifier({ name: "env" }) && path.get("object")?.get("object")?.isIdentifier({ name: "process" }) && path.get("property")?.isIdentifier()) {
+				const identifier = path.get("property")?.node;
+				if (!identifier.name) return;
+				extractEnv(identifier, pass, false);
+				path.replaceWithSourceString(`env.${identifier.name}`);
+				addImport(path, {
+					module: "storm:env",
+					name: "env",
+					imported: "env"
+				});
+			} else if (path.get("object")?.get("property")?.isIdentifier({ name: "env" }) && path.get("object")?.get("object")?.isMetaProperty() && path.get("property")?.isIdentifier()) {
+				const identifier = path.get("property")?.node;
+				if (!identifier.name) return;
+				extractEnv(identifier, pass, false);
+				path.replaceWithSourceString(`env.${identifier.name}`);
+				addImport(path, {
+					module: "storm:env",
+					name: "env",
+					imported: "env"
+				});
+			}
+		} },
+		post() {
+			log(LogLevelLabel.TRACE, `Adding environment variables from ${this.filename || "unknown file"} to env.json.`);
+			let persistedEnv = ReflectionClass.from({
+				kind: ReflectionKind.objectLiteral,
+				description: `An object containing the environment variables used by the application.`,
+				types: []
+			});
+			const reflectionPath = getEnvReflectionsPath(context, "env");
+			if (reflectionPath && existsSync$1(reflectionPath)) {
+				log(LogLevelLabel.TRACE, `Environment reflection file found at ${reflectionPath}, reading existing reflection.`);
+				persistedEnv = resolveClassType(deserializeType(convertFromCapnp(new capnp.Message(readFileBufferSync(reflectionPath), false).getRoot(SerializedTypes).types)));
+			}
+			log(LogLevelLabel.TRACE, `Adding new variables to env reflection at ${reflectionPath}.`);
+			persistedEnv.getProperties().filter((property) => property.getNameAsString() && !context.env.used.env.hasProperty(property.getNameAsString())).forEach((property) => {
+				context.env.used.env.addProperty({
+					...property,
+					name: property.getNameAsString(),
+					description: property.getDescription() ?? `The ${property.getNameAsString()} variable.`,
+					default: property.getDefaultValue(),
+					optional: property.isOptional() ? true : void 0,
+					readonly: property.isReadonly() ? true : void 0,
+					visibility: property.getVisibility(),
+					type: property.getType(),
+					tags: property.getTags()
+				});
+			});
+		}
+	};
+});
+
+//#endregion
+//#region src/helpers/automd-generator.ts
+/**
+* AutoMD generator to generate environment variable documentation
+*
+* @param context - The generator context.
+* @returns The generated documentation content.
+*/
+const env = (context) => defineGenerator({
+	name: "env",
+	async generate() {
+		const envDocFile = joinPaths(context.config.projectRoot, "docs", "generated", "env.md");
+		if (!context.fs.existsSync(envDocFile)) return { contents: "" };
+		return { contents: await context.fs.read(envDocFile) || "" };
+	}
+});
+
+//#endregion
+//#region src/helpers/template-helpers.ts
+/**
+* Creates the reflection data used when generating runtime template files.
+*
+* @param context - The context for the configuration plugin.
+* @param name - The name of the configuration template.
+* @returns The reflection for the specified configuration template.
+*/
+async function createTemplateReflection(context, name) {
+	const reflection = await readEnvTypeReflection(context, name);
+	reflection.getProperties().forEach((prop) => {
+		prop.getAlias().filter(Boolean).forEach((alias) => {
+			reflection.addProperty({
+				name: alias,
+				optional: prop.isOptional() ? true : void 0,
+				readonly: prop.isReadonly() ? true : void 0,
+				description: prop.getDescription(),
+				visibility: prop.getVisibility(),
+				type: prop.getType(),
+				default: prop.getDefaultValue(),
+				tags: {
+					hidden: prop.isHidden(),
+					ignore: prop.isIgnored(),
+					internal: prop.isInternal(),
+					alias: prop.getAlias().filter((a) => a !== alias).concat(prop.name),
+					title: prop.getTitle() || titleCase(prop.name),
+					readonly: prop.isReadonly(),
+					permission: prop.getPermission(),
+					domain: prop.getDomain()
+				}
+			});
+		});
+	});
+	return reflection;
+}
+
+//#endregion
 //#region src/index.tsx
 /**
 * A Powerlines plugin to inject environment variables into the source code.
@@ -88,10 +708,10 @@ const plugin = (options = {}) => {
 					if (existsSync(getEnvTypeReflectionsPath(this, "secrets"))) this.env.types.secrets = await readEnvTypeReflection(this, "secrets");
 					if (existsSync(getEnvReflectionsPath(this, "secrets"))) this.env.used.secrets = await readSecretsReflection(this);
 				} else {
-					this.env.types.env = await reflectEnv(this, this.config.env.types?.file ? isParentPath(this.config.env.types?.file, this.workspaceConfig.workspaceRoot) ? this.config.env.types?.file : joinPaths(this.config.projectRoot, this.config.env.types?.file) : void 0, this.config.env.types?.name);
+					this.env.types.env = await reflectEnv(this, this.config.env.types?.file ? isParentPath(this.config.env.types?.file, this.workspaceConfig.workspaceRoot) ? this.config.env.types?.file : joinPaths$1(this.config.projectRoot, this.config.env.types?.file) : void 0, this.config.env.types?.name);
 					if (!this.env.types.env) throw new Error("Failed to find the environment configuration type reflection in the context.");
 					await writeEnvTypeReflection(this, this.env.types.env, "env");
-					this.env.types.secrets = await reflectSecrets(this, this.config.env.secrets?.file ? isParentPath(this.config.env.secrets?.file, this.workspaceConfig.workspaceRoot) ? this.config.env.secrets?.file : joinPaths(this.config.projectRoot, this.config.env.secrets?.file) : void 0, this.config.env.secrets?.name);
+					this.env.types.secrets = await reflectSecrets(this, this.config.env.secrets?.file ? isParentPath(this.config.env.secrets?.file, this.workspaceConfig.workspaceRoot) ? this.config.env.secrets?.file : joinPaths$1(this.config.projectRoot, this.config.env.secrets?.file) : void 0, this.config.env.secrets?.name);
 					if (!this.env.types.secrets) throw new Error("Failed to find the secrets configuration type reflection in the context.");
 					await writeEnvTypeReflection(this, this.env.types.secrets, "secrets");
 					this.log(LogLevelLabel.TRACE, `Resolved ${this.env.types.env.getProperties().length ?? 0} environment configuration parameters and ${this.env.types.secrets?.getProperties().length ?? 0} secret configuration parameters`);
@@ -104,8 +724,8 @@ const plugin = (options = {}) => {
 						const aliasKey = envWithAlias.find((prop) => prop?.getAlias().reverse().includes(unprefixedKey));
 						if (this.env.types.env?.hasProperty(unprefixedKey) || aliasKey) this.env.types.env.getProperty(unprefixedKey).setDefaultValue(value);
 					});
-					this.env.used.env = new type_exports.ReflectionClass({
-						kind: type_exports.ReflectionKind.objectLiteral,
+					this.env.used.env = new ReflectionClass({
+						kind: ReflectionKind.objectLiteral,
 						typeName: "Env",
 						description: `An object containing the environment configuration parameters used by the ${this.config.name ? `${this.config.name} application` : "application"}.`,
 						types: []
@@ -113,8 +733,8 @@ const plugin = (options = {}) => {
 					await writeEnvReflection(this, this.env.used.env, "env");
 					if (this.env.types.secrets) {
 						await writeEnvTypeReflection(this, this.env.types.secrets, "secrets");
-						this.env.used.secrets = new type_exports.ReflectionClass({
-							kind: type_exports.ReflectionKind.objectLiteral,
+						this.env.used.secrets = new ReflectionClass({
+							kind: ReflectionKind.objectLiteral,
 							typeName: "Secrets",
 							description: `An object containing the secret configuration parameters used by the ${this.config.name ? `${this.config.name} application` : "application"}.`,
 							types: []
@@ -132,10 +752,10 @@ const plugin = (options = {}) => {
 			},
 			async docs() {
 				this.log(LogLevelLabel.TRACE, "Writing Environment documentation for the Powerlines project artifacts.");
-				const outputPath = joinPaths(this.config.projectRoot, "docs", "generated");
+				const outputPath = joinPaths$1(this.config.projectRoot, "docs", "generated");
 				if (!existsSync(outputPath)) await createDirectory(outputPath);
 				const reflection = await readEnvTypeReflection(this, "env");
-				const envDocFile = joinPaths(outputPath, "env.md");
+				const envDocFile = joinPaths$1(outputPath, "env.md");
 				this.log(LogLevelLabel.TRACE, `Documenting environment variables configuration in "${envDocFile}"`);
 				await this.fs.write(envDocFile, `<!-- Generated by ${titleCase(this.config.framework) || "Powerlines"} -->
 
@@ -144,7 +764,7 @@ Below is a list of environment variables used by the [${this.packageJson.name}](
 | Name | Description | Type | Default Value | Required |
 | ---- | ----------- | ---- | ------------- | :------: |
 ${reflection.getProperties().filter((property) => property.getNameAsString() !== "__POWERLINES_INJECTED__").sort((a, b) => a.getNameAsString().localeCompare(b.getNameAsString())).map((reflectionProperty) => {
-					return `| ${reflectionProperty.getNameAsString().trim()} | ${(reflectionProperty.getDescription()?.replaceAll("\r", "")?.replaceAll("\n", "") ?? "").trim()} | ${(0, type_exports.stringifyType)(reflectionProperty.getType()).trim().replaceAll(" | ", ", or ")} | ${reflectionProperty.hasDefault() ? String(reflectionProperty.getDefaultValue())?.includes("\"") ? reflectionProperty.getDefaultValue() : `\`${reflectionProperty.getDefaultValue()}\`` : ""} | ${reflectionProperty.isValueRequired() ? "" : "✔"} |`;
+					return `| ${reflectionProperty.getNameAsString().trim()} | ${(reflectionProperty.getDescription()?.replaceAll("\r", "")?.replaceAll("\n", "") ?? "").trim()} | ${stringifyType(reflectionProperty.getType()).trim().replaceAll(" | ", ", or ")} | ${reflectionProperty.hasDefault() ? String(reflectionProperty.getDefaultValue())?.includes("\"") ? reflectionProperty.getDefaultValue() : `\`${reflectionProperty.getDefaultValue()}\`` : ""} | ${reflectionProperty.isValueRequired() ? "" : "✔"} |`;
 				}).join("\n")}
 `);
 			},