@powerlines/plugin-env 0.15.2 → 0.15.4

package/dist/index.cjs

@@ -1,44 +1,669 @@
 Object.defineProperty(exports, '__esModule', { value: true });
-const require_rolldown_runtime = require('./_virtual/rolldown_runtime.cjs');
-const require_type = require('./deepkit/src/vendor/type.cjs');
-const require_index = require('./plugin-alloy/src/index.cjs');
-const require_index$1 = require('./plugin-automd/src/index.cjs');
-const require_index$2 = require('./plugin-babel/src/index.cjs');
-const require_reflect = require('./helpers/reflect.cjs');
-const require_persistence = require('./helpers/persistence.cjs');
-const require_plugin = require('./babel/plugin.cjs');
-const require_source_file_env = require('./helpers/source-file-env.cjs');
-const require_load = require('./helpers/load.cjs');
-const require_create_reflection_resource = require('./helpers/create-reflection-resource.cjs');
-const require_components_env = require('./components/env.cjs');
-const require_automd_generator = require('./helpers/automd-generator.cjs');
-require('./babel/index.cjs');
-const require_components_docs = require('./components/docs.cjs');
-require('./components/index.cjs');
-const require_template_helpers = require('./helpers/template-helpers.cjs');
-require('./helpers/index.cjs');
+const require_create_reflection_resource = require('./create-reflection-resource-BWYhmX7O.cjs');
+const require_env = require('./env-cO4BUDn1.cjs');
+const require_docs = require('./docs-hBlKCRWK.cjs');
+require('./components-C9bYrQVK.cjs');
+require('./plugin-D5qyQPqC.cjs');
+require('./runtime-Bisl_1Ja.cjs');
+require('./types-MYBaygjr.cjs');
 let __alloy_js_core_jsx_runtime = require("@alloy-js/core/jsx-runtime");
+let __powerlines_deepkit_vendor_type = require("@powerlines/deepkit/vendor/type");
+let __alloy_js_core = require("@alloy-js/core");
+let __alloy_js_rollup_plugin = require("@alloy-js/rollup-plugin");
+__alloy_js_rollup_plugin = require_create_reflection_resource.__toESM(__alloy_js_rollup_plugin);
+let __stryke_json_storm_json = require("@stryke/json/storm-json");
+let __stryke_path_replace = require("@stryke/path/replace");
 let __stryke_convert_to_array = require("@stryke/convert/to-array");
+let __stryke_fs_is_file = require("@stryke/fs/is-file");
+let __stryke_fs_list_files = require("@stryke/fs/list-files");
+let __stryke_path_append = require("@stryke/path/append");
+let __stryke_path_is_type = require("@stryke/path/is-type");
+let __stryke_path_join_paths = require("@stryke/path/join-paths");
+let automd = require("automd");
+let c12 = require("c12");
 let defu = require("defu");
-defu = require_rolldown_runtime.__toESM(defu);
+defu = require_create_reflection_resource.__toESM(defu);
+let markdown_toc = require("markdown-toc");
+markdown_toc = require_create_reflection_resource.__toESM(markdown_toc);
+let __babel_core = require("@babel/core");
 let __storm_software_config_tools_types = require("@storm-software/config-tools/types");
+let __stryke_path_file_path_fns = require("@stryke/path/file-path-fns");
 let __stryke_path_is_parent_path = require("@stryke/path/is-parent-path");
+let __stryke_type_checks_is_set_object = require("@stryke/type-checks/is-set-object");
+let __stryke_type_checks_is_function = require("@stryke/type-checks/is-function");
+require("@stryke/type-checks/is-object");
+let __stryke_type_checks_is_set_string = require("@stryke/type-checks/is-set-string");
+let chalk = require("chalk");
+chalk = require_create_reflection_resource.__toESM(chalk);
+let __babel_generator = require("@babel/generator");
+__babel_generator = require_create_reflection_resource.__toESM(__babel_generator);
+require("@babel/parser");
+let __babel_helper_plugin_utils = require("@babel/helper-plugin-utils");
+require("@storm-software/config-tools/logger");
+require("@storm-software/config-tools/utilities/colors");
+require("@stryke/helpers/noop");
+let __stryke_string_format_kebab_case = require("@stryke/string-format/kebab-case");
 let __stryke_string_format_title_case = require("@stryke/string-format/title-case");
+let __babel_types = require("@babel/types");
+__babel_types = require_create_reflection_resource.__toESM(__babel_types);
+let __stryke_type_checks_is_string = require("@stryke/type-checks/is-string");
 let __stryke_convert_parse_type_definition = require("@stryke/convert/parse-type-definition");
 let __stryke_env_types = require("@stryke/env/types");
 let __stryke_fs_exists = require("@stryke/fs/exists");
 let __stryke_fs_helpers = require("@stryke/fs/helpers");
 let __stryke_path_join = require("@stryke/path/join");
 let __stryke_string_format_constant_case = require("@stryke/string-format/constant-case");
+let __stryke_capnp = require("@stryke/capnp");
+__stryke_capnp = require_create_reflection_resource.__toESM(__stryke_capnp);
+let __stryke_fs_buffer = require("@stryke/fs/buffer");
+let node_fs = require("node:fs");
 
+//#region ../plugin-alloy/src/core/components/output.tsx
+/**
+* Output component for rendering the Powerlines plugin's output files via templates.
+*/
+function Output(props) {
+	const [{ children, context, meta, basePath }, rest] = (0, __alloy_js_core.splitProps)(props, [
+		"children",
+		"context",
+		"meta",
+		"basePath"
+	]);
+	const contextRef = (0, __alloy_js_core.ref)(context);
+	const metaRef = (0, __alloy_js_core.ref)(meta ?? {});
+	const basePathRef = (0, __alloy_js_core.computed)(() => basePath ? (0, __stryke_path_replace.replacePath)(basePath, contextRef.value.workspaceConfig.workspaceRoot) : contextRef.value.workspaceConfig.workspaceRoot);
+	return (0, __alloy_js_core_jsx_runtime.createComponent)(__alloy_js_core.Output, (0, __alloy_js_core_jsx_runtime.mergeProps)(rest, {
+		get basePath() {
+			return basePathRef.value;
+		},
+		get children() {
+			return (0, __alloy_js_core_jsx_runtime.createComponent)(require_create_reflection_resource.PowerlinesContext.Provider, {
+				value: {
+					ref: contextRef,
+					meta: metaRef
+				},
+				get children() {
+					return (0, __alloy_js_core_jsx_runtime.createComponent)(__alloy_js_core.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: [(0, __alloy_js_rollup_plugin.default)()]
+				}
+			};
+		},
+		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, __stryke_json_storm_json.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 (0, __alloy_js_core.traverseOutput)(await (0, __alloy_js_core.renderAsync)((0, __alloy_js_core_jsx_runtime.createComponent)(Output, {
+						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 (0, automd.loadConfig)((0, __stryke_path_join_paths.joinPaths)(this.workspaceConfig.workspaceRoot, this.config.projectRoot), options);
+			if (!config.prefix || !Array.isArray(config.prefix)) config.prefix = (0, __stryke_convert_to_array.toArray)(config.prefix ?? []);
+			if (!config.prefix.includes("automd")) config.prefix.push("automd");
+			if (!config.prefix.includes("powerlines")) config.prefix.push("powerlines");
+			return { automd: (0, defu.default)(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 && !(0, __stryke_convert_to_array.toArray)(this.config.automd.prefix).includes(this.config.framework)) this.config.automd.prefix = (0, __stryke_convert_to_array.toArray)(this.config.automd.prefix).concat(this.config.framework);
+			if (this.config.automd.configFile) {
+				const { config } = await (0, c12.loadConfig)({
+					cwd: this.config.automd.dir,
+					configFile: this.config.automd.configFile,
+					defaults: {
+						ignore: [
+							"**/node_modules",
+							"**/dist",
+							"**/.*"
+						],
+						dir: this.config.automd.dir
+					}
+				});
+				this.config.automd = (0, automd.resolveConfig)((0, defu.default)(this.config.automd, {
+					...config,
+					prefix: (0, __stryke_convert_to_array.toArray)(config.prefix ?? [])
+				}));
+			}
+			this.config.automd.input = (await Promise.all((0, __stryke_convert_to_array.toArray)(this.config.automd.input).map(async (input) => {
+				if (input.includes("*")) return (0, __stryke_fs_list_files.listFiles)((0, __stryke_path_is_type.isAbsolutePath)(input) ? input : (0, __stryke_path_append.appendPath)(input, this.config.projectRoot), { ignore: this.config.automd.ignore });
+				return (0, __stryke_path_is_type.isAbsolutePath)(input) ? input : (0, __stryke_path_append.appendPath)(input, this.config.projectRoot);
+			}))).flat();
+			if (this.config.automd.output && !(0, __stryke_path_is_type.isAbsolutePath)(this.config.automd.output)) this.config.automd.output = (0, __stryke_path_append.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: (0, markdown_toc.default)(ctx.block.md, {
+						...opts,
+						maxdepth: opts.maxDepth,
+						first1: opts.firstH1
+					}).content };
+				}
+			};
+		},
+		async docs() {
+			await Promise.all((0, __stryke_convert_to_array.toArray)(this.config.automd.input).map(async (input) => {
+				const contents = await this.fs.read(input);
+				if (contents) {
+					const result = await (0, automd.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((0, __stryke_path_append.appendPath)(this.config.automd.output ? (0, __stryke_fs_is_file.isDirectory)(this.config.automd.output) ? (0, __stryke_path_replace.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 (0, __stryke_type_checks_is_set_string.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] ? (0, __stryke_type_checks_is_function.isFunction)(plugin$4[0]) ? plugin$4[0](context) : plugin$4[0] : (0, __stryke_type_checks_is_function.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, id, plugin$4) {
+	if (Array.isArray(plugin$4) && plugin$4.length > 0 && plugin$4[0]) {
+		if (plugin$4.length > 2 && plugin$4[2] && (0, __stryke_type_checks_is_function.isFunction)(plugin$4[2]) && !plugin$4[2](code, id)) {
+			context.log(__storm_software_config_tools_types.LogLevelLabel.TRACE, `Skipping filtered Babel plugin ${chalk.default.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 = __babel_generator.default;
+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.default.inverse.hex(BADGE_COLORS[name.split("").map((char) => char.charCodeAt(0)).reduce((ret, charCode) => ret + charCode, 0) % BADGE_COLORS.length] || BADGE_COLORS[0])(` ${(0, __stryke_string_format_title_case.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 (0, __babel_helper_plugin_utils.declare)((api, options, dirname) => {
+			api.cache.using(() => context.meta.checksum);
+			api.assertVersion("^7.0.0-0");
+			const log = extendLog(context.log, name);
+			log(__storm_software_config_tools_types.LogLevelLabel.TRACE, `Initializing the ${chalk.default.bold.cyanBright(name)} Babel plugin`);
+			const result = builder({
+				log,
+				name,
+				api,
+				options,
+				context,
+				dirname
+			});
+			result.name = name;
+			log(__storm_software_config_tools_types.LogLevelLabel.TRACE, `Completed initialization of the ${chalk.default.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", __babel_types.importDeclaration([__babel_types.importSpecifier(__babel_types.identifier(specifier.name || specifier.imported), __babel_types.identifier(specifier.imported))], __babel_types.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 (!(0, __stryke_type_checks_is_set_object.isSetObject)(options)) return;
+			return { transform: { babel: options } };
+		},
+		configResolved: {
+			order: "pre",
+			handler() {
+				this.devDependencies["@babel/core"] = "^7.28.4";
+				this.config.transform.babel = (0, defu.default)(this.config.transform.babel ?? {}, {
+					plugins: [],
+					presets: []
+				});
+			}
+		},
+		async transform(code, id) {
+			if ((0, __stryke_path_is_parent_path.isParentPath)(id, this.powerlinesPath) || code.includes("/* @storm-ignore */") || code.includes("/* @storm-disable */")) {
+				this.log(__storm_software_config_tools_types.LogLevelLabel.TRACE, `Skipping Babel transformation for: ${id}`);
+				return {
+					code,
+					id
+				};
+			}
+			this.log(__storm_software_config_tools_types.LogLevelLabel.TRACE, `Babel transforming file: ${id}`);
+			const plugins = this.config.transform.babel.plugins.map((plugin$4) => resolveBabelPlugin(this, code, 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, id, preset)).filter((preset, _, arr) => preset && !isDuplicatePlugin(arr, preset));
+			if (Array.isArray(plugins) && plugins.length === 0 && Array.isArray(presets) && presets.length === 0) return {
+				code,
+				id
+			};
+			if ([
+				"ts",
+				"cts",
+				"mts",
+				"tsx"
+			].includes((0, __stryke_path_file_path_fns.findFileExtensionSafe)(id)) && !isDuplicatePlugin(plugins, "@babel/plugin-syntax-typescript") && !isDuplicatePlugin(presets, "@babel/preset-typescript")) plugins.unshift(["@babel/plugin-syntax-typescript", { isTSX: (0, __stryke_path_file_path_fns.findFileExtension)(id) === ".tsx" }]);
+			const result = await (0, __babel_core.transformAsync)(code, {
+				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], (0, defu.default)(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], (0, defu.default)(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(__storm_software_config_tools_types.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 require_env.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(__storm_software_config_tools_types.LogLevelLabel.TRACE, `Adding environment variables from ${this.filename || "unknown file"} to env.json.`);
+			let persistedEnv = __powerlines_deepkit_vendor_type.ReflectionClass.from({
+				kind: __powerlines_deepkit_vendor_type.ReflectionKind.objectLiteral,
+				description: `An object containing the environment variables used by the application.`,
+				types: []
+			});
+			const reflectionPath = require_create_reflection_resource.getEnvReflectionsPath(context, "env");
+			if (reflectionPath && (0, node_fs.existsSync)(reflectionPath)) {
+				log(__storm_software_config_tools_types.LogLevelLabel.TRACE, `Environment reflection file found at ${reflectionPath}, reading existing reflection.`);
+				persistedEnv = (0, __powerlines_deepkit_vendor_type.resolveClassType)((0, __powerlines_deepkit_vendor_type.deserializeType)(require_create_reflection_resource.convertFromCapnp(new __stryke_capnp.Message((0, __stryke_fs_buffer.readFileBufferSync)(reflectionPath), false).getRoot(require_create_reflection_resource.SerializedTypes).types)));
+			}
+			log(__storm_software_config_tools_types.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) => (0, automd.defineGenerator)({
+	name: "env",
+	async generate() {
+		const envDocFile = (0, __stryke_path_join_paths.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 require_create_reflection_resource.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() || (0, __stryke_string_format_title_case.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.
 */
 const plugin = (options = {}) => {
 	return [
-		require_index.default(options.alloy),
-		require_index$2.default(options.babel),
+		src_default$1(options.alloy),
+		src_default$3(options.babel),
 		{
 			name: "env",
 			async config() {
@@ -48,17 +673,17 @@ const plugin = (options = {}) => {
 						types: {},
 						prefix: []
 					}),
-					transform: { babel: { plugins: [require_plugin.envBabelPlugin] } }
+					transform: { babel: { plugins: [envBabelPlugin] } }
 				};
 				if (config.env.types) config.env.types = (0, __stryke_convert_parse_type_definition.parseTypeDefinition)(config.env.types);
 				else {
 					this.log(__storm_software_config_tools_types.LogLevelLabel.WARN, "The `env.types` configuration parameter was not provided. Please ensure this is expected.");
-					const envDefaultTypeDefinition = await require_persistence.getEnvDefaultTypeDefinition(this);
+					const envDefaultTypeDefinition = await require_create_reflection_resource.getEnvDefaultTypeDefinition(this);
 					config.env.types = (0, __stryke_convert_parse_type_definition.parseTypeDefinition)(`${envDefaultTypeDefinition.file}#${envDefaultTypeDefinition.name}`);
 				}
 				if (config.env.secrets) config.env.secrets = (0, __stryke_convert_parse_type_definition.parseTypeDefinition)(config.env.secrets);
 				else {
-					const secretsDefaultTypeDefinition = await require_persistence.getSecretsDefaultTypeDefinition(this);
+					const secretsDefaultTypeDefinition = await require_create_reflection_resource.getSecretsDefaultTypeDefinition(this);
 					config.env.secrets = (0, __stryke_convert_parse_type_definition.parseTypeDefinition)(`${secretsDefaultTypeDefinition.file}#${secretsDefaultTypeDefinition.name}`);
 				}
 				config.env.prefix = (0, __stryke_convert_to_array.toArray)(config.env.prefix ?? []).reduce((ret, prefix) => {
@@ -75,7 +700,7 @@ const plugin = (options = {}) => {
 			async configResolved() {
 				this.log(__storm_software_config_tools_types.LogLevelLabel.TRACE, `Environment plugin configuration has been resolved for the Powerlines project.`);
 				this.config.env.inject ??= this.config.projectType === "application";
-				this.env = (0, defu.default)({ parsed: await require_load.loadEnv(this, this.config.env) }, this.env ?? {}, {
+				this.env = (0, defu.default)({ parsed: await require_create_reflection_resource.loadEnv(this, this.config.env) }, this.env ?? {}, {
 					types: { env: {} },
 					used: {
 						env: {},
@@ -84,22 +709,22 @@ const plugin = (options = {}) => {
 					parsed: {},
 					injected: {}
 				});
-				if (this.config.command !== "prepare" && this.persistedMeta?.checksum === this.meta.checksum && (0, __stryke_fs_exists.existsSync)(require_persistence.getEnvTypeReflectionsPath(this, "env"))) {
+				if (this.config.command !== "prepare" && this.persistedMeta?.checksum === this.meta.checksum && (0, __stryke_fs_exists.existsSync)(require_create_reflection_resource.getEnvTypeReflectionsPath(this, "env"))) {
 					this.log(__storm_software_config_tools_types.LogLevelLabel.TRACE, `Skipping reflection initialization as the meta checksum has not changed.`);
-					this.env.types.env = await require_persistence.readEnvTypeReflection(this, "env");
-					if ((0, __stryke_fs_exists.existsSync)(require_persistence.getEnvReflectionsPath(this, "env"))) this.env.used.env = await require_persistence.readEnvReflection(this);
-					if ((0, __stryke_fs_exists.existsSync)(require_persistence.getEnvTypeReflectionsPath(this, "secrets"))) this.env.types.secrets = await require_persistence.readEnvTypeReflection(this, "secrets");
-					if ((0, __stryke_fs_exists.existsSync)(require_persistence.getEnvReflectionsPath(this, "secrets"))) this.env.used.secrets = await require_persistence.readSecretsReflection(this);
+					this.env.types.env = await require_create_reflection_resource.readEnvTypeReflection(this, "env");
+					if ((0, __stryke_fs_exists.existsSync)(require_create_reflection_resource.getEnvReflectionsPath(this, "env"))) this.env.used.env = await require_create_reflection_resource.readEnvReflection(this);
+					if ((0, __stryke_fs_exists.existsSync)(require_create_reflection_resource.getEnvTypeReflectionsPath(this, "secrets"))) this.env.types.secrets = await require_create_reflection_resource.readEnvTypeReflection(this, "secrets");
+					if ((0, __stryke_fs_exists.existsSync)(require_create_reflection_resource.getEnvReflectionsPath(this, "secrets"))) this.env.used.secrets = await require_create_reflection_resource.readSecretsReflection(this);
 				} else {
-					this.env.types.env = await require_reflect.reflectEnv(this, this.config.env.types?.file ? (0, __stryke_path_is_parent_path.isParentPath)(this.config.env.types?.file, this.workspaceConfig.workspaceRoot) ? this.config.env.types?.file : (0, __stryke_path_join.joinPaths)(this.config.projectRoot, this.config.env.types?.file) : void 0, this.config.env.types?.name);
+					this.env.types.env = await require_create_reflection_resource.reflectEnv(this, this.config.env.types?.file ? (0, __stryke_path_is_parent_path.isParentPath)(this.config.env.types?.file, this.workspaceConfig.workspaceRoot) ? this.config.env.types?.file : (0, __stryke_path_join.joinPaths)(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 require_persistence.writeEnvTypeReflection(this, this.env.types.env, "env");
-					this.env.types.secrets = await require_reflect.reflectSecrets(this, this.config.env.secrets?.file ? (0, __stryke_path_is_parent_path.isParentPath)(this.config.env.secrets?.file, this.workspaceConfig.workspaceRoot) ? this.config.env.secrets?.file : (0, __stryke_path_join.joinPaths)(this.config.projectRoot, this.config.env.secrets?.file) : void 0, this.config.env.secrets?.name);
+					await require_create_reflection_resource.writeEnvTypeReflection(this, this.env.types.env, "env");
+					this.env.types.secrets = await require_create_reflection_resource.reflectSecrets(this, this.config.env.secrets?.file ? (0, __stryke_path_is_parent_path.isParentPath)(this.config.env.secrets?.file, this.workspaceConfig.workspaceRoot) ? this.config.env.secrets?.file : (0, __stryke_path_join.joinPaths)(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 require_persistence.writeEnvTypeReflection(this, this.env.types.secrets, "secrets");
+					await require_create_reflection_resource.writeEnvTypeReflection(this, this.env.types.secrets, "secrets");
 					this.log(__storm_software_config_tools_types.LogLevelLabel.TRACE, `Resolved ${this.env.types.env.getProperties().length ?? 0} environment configuration parameters and ${this.env.types.secrets?.getProperties().length ?? 0} secret configuration parameters`);
 					const envWithAlias = this.env.types.env.getProperties().filter((prop) => prop.getAlias().length > 0);
-					Object.entries(await require_load.loadEnv(this, this.config.env)).forEach(([key, value]) => {
+					Object.entries(await require_create_reflection_resource.loadEnv(this, this.config.env)).forEach(([key, value]) => {
 						const unprefixedKey = this.config.env.prefix.reduce((ret, prefix) => {
 							if (key.replace(/_$/g, "").startsWith(prefix)) return key.replace(/_$/g, "").slice(prefix.length);
 							return ret;
@@ -107,29 +732,29 @@ 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 require_type.type_exports.ReflectionClass({
-						kind: require_type.type_exports.ReflectionKind.objectLiteral,
+					this.env.used.env = new __powerlines_deepkit_vendor_type.ReflectionClass({
+						kind: __powerlines_deepkit_vendor_type.ReflectionKind.objectLiteral,
 						typeName: "Env",
 						description: `An object containing the environment configuration parameters used by the ${this.config.name ? `${this.config.name} application` : "application"}.`,
 						types: []
 					}, this.env.types.env);
-					await require_persistence.writeEnvReflection(this, this.env.used.env, "env");
+					await require_create_reflection_resource.writeEnvReflection(this, this.env.used.env, "env");
 					if (this.env.types.secrets) {
-						await require_persistence.writeEnvTypeReflection(this, this.env.types.secrets, "secrets");
-						this.env.used.secrets = new require_type.type_exports.ReflectionClass({
-							kind: require_type.type_exports.ReflectionKind.objectLiteral,
+						await require_create_reflection_resource.writeEnvTypeReflection(this, this.env.types.secrets, "secrets");
+						this.env.used.secrets = new __powerlines_deepkit_vendor_type.ReflectionClass({
+							kind: __powerlines_deepkit_vendor_type.ReflectionKind.objectLiteral,
 							typeName: "Secrets",
 							description: `An object containing the secret configuration parameters used by the ${this.config.name ? `${this.config.name} application` : "application"}.`,
 							types: []
 						}, this.env.types.secrets);
-						await require_persistence.writeEnvReflection(this, this.env.used.secrets, "secrets");
+						await require_create_reflection_resource.writeEnvReflection(this, this.env.used.secrets, "secrets");
 					}
 				}
 			},
 			async prepare() {
 				const _self$ = this;
 				this.log(__storm_software_config_tools_types.LogLevelLabel.TRACE, `Preparing the Environment runtime artifacts for the Powerlines project.`);
-				return this.render((0, __alloy_js_core_jsx_runtime.createComponent)(require_components_env.EnvBuiltin, { get defaultConfig() {
+				return this.render((0, __alloy_js_core_jsx_runtime.createComponent)(require_env.EnvBuiltin, { get defaultConfig() {
 					return _self$.config.env.defaultConfig;
 				} }));
 			},
@@ -137,7 +762,7 @@ const plugin = (options = {}) => {
 				this.log(__storm_software_config_tools_types.LogLevelLabel.TRACE, "Writing Environment documentation for the Powerlines project artifacts.");
 				const outputPath = (0, __stryke_path_join.joinPaths)(this.config.projectRoot, "docs", "generated");
 				if (!(0, __stryke_fs_exists.existsSync)(outputPath)) await (0, __stryke_fs_helpers.createDirectory)(outputPath);
-				const reflection = await require_persistence.readEnvTypeReflection(this, "env");
+				const reflection = await require_create_reflection_resource.readEnvTypeReflection(this, "env");
 				const envDocFile = (0, __stryke_path_join.joinPaths)(outputPath, "env.md");
 				this.log(__storm_software_config_tools_types.LogLevelLabel.TRACE, `Documenting environment variables configuration in "${envDocFile}"`);
 				await this.fs.write(envDocFile, `<!-- Generated by ${(0, __stryke_string_format_title_case.titleCase)(this.config.framework) || "Powerlines"} -->
@@ -147,20 +772,20 @@ 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, require_type.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()} | ${(0, __powerlines_deepkit_vendor_type.stringifyType)(reflectionProperty.getType()).trim().replaceAll(" | ", ", or ")} | ${reflectionProperty.hasDefault() ? String(reflectionProperty.getDefaultValue())?.includes("\"") ? reflectionProperty.getDefaultValue() : `\`${reflectionProperty.getDefaultValue()}\`` : ""} | ${reflectionProperty.isValueRequired() ? "" : "✔"} |`;
 				}).join("\n")}
 `);
 			},
 			async buildEnd() {
-				const reflectionPath = require_persistence.getEnvReflectionsPath(this, "env");
+				const reflectionPath = require_create_reflection_resource.getEnvReflectionsPath(this, "env");
 				this.log(__storm_software_config_tools_types.LogLevelLabel.TRACE, `Writing env reflection types to ${reflectionPath}.`);
-				await require_persistence.writeEnvReflection(this, this.env.used.env, "env");
+				await require_create_reflection_resource.writeEnvReflection(this, this.env.used.env, "env");
 			}
 		},
 		{
 			name: "env:automd-generator",
 			config() {
-				return { automd: (0, defu.default)(options.automd ?? {}, { generators: { "env": require_automd_generator.env(this) } }) };
+				return { automd: (0, defu.default)(options.automd ?? {}, { generators: { "env": env(this) } }) };
 			}
 		},
 		{
@@ -169,40 +794,40 @@ ${reflection.getProperties().filter((property) => property.getNameAsString() !==
 				return { envPrefix: this.config?.env?.prefix };
 			} }
 		},
-		require_index$1.default(options.automd)
+		src_default$2(options.automd)
 	];
 };
 var src_default = plugin;
 
 //#endregion
-exports.BaseEnv = require_reflect.BaseEnv;
-exports.BaseSecrets = require_reflect.BaseSecrets;
-exports.EnvBuiltin = require_components_env.EnvBuiltin;
-exports.EnvDocs = require_components_docs.EnvDocs;
-exports.EnvTypeDefinition = require_components_env.EnvTypeDefinition;
-exports.createEnvReflection = require_reflect.createEnvReflection;
+exports.BaseEnv = require_create_reflection_resource.BaseEnv;
+exports.BaseSecrets = require_create_reflection_resource.BaseSecrets;
+exports.EnvBuiltin = require_env.EnvBuiltin;
+exports.EnvDocs = require_docs.EnvDocs;
+exports.EnvTypeDefinition = require_env.EnvTypeDefinition;
+exports.createEnvReflection = require_create_reflection_resource.createEnvReflection;
 exports.createReflectionResource = require_create_reflection_resource.createReflectionResource;
-exports.createSecretsReflection = require_reflect.createSecretsReflection;
-exports.createTemplateReflection = require_template_helpers.createTemplateReflection;
+exports.createSecretsReflection = require_create_reflection_resource.createSecretsReflection;
+exports.createTemplateReflection = createTemplateReflection;
 exports.default = src_default;
-exports.envBabelPlugin = require_plugin.envBabelPlugin;
-exports.formatEnvField = require_source_file_env.formatEnvField;
-exports.getEnvDefaultTypeDefinition = require_persistence.getEnvDefaultTypeDefinition;
-exports.getEnvReflectionsPath = require_persistence.getEnvReflectionsPath;
-exports.getEnvTypeReflectionsPath = require_persistence.getEnvTypeReflectionsPath;
-exports.getSecretsDefaultTypeDefinition = require_persistence.getSecretsDefaultTypeDefinition;
-exports.loadEnv = require_load.loadEnv;
-exports.loadEnvFromContext = require_load.loadEnvFromContext;
-exports.mergeEnvReflections = require_reflect.mergeEnvReflections;
-exports.mergeSecretsReflections = require_reflect.mergeSecretsReflections;
+exports.envBabelPlugin = envBabelPlugin;
+exports.formatEnvField = require_create_reflection_resource.formatEnvField;
+exports.getEnvDefaultTypeDefinition = require_create_reflection_resource.getEnvDefaultTypeDefinition;
+exports.getEnvReflectionsPath = require_create_reflection_resource.getEnvReflectionsPath;
+exports.getEnvTypeReflectionsPath = require_create_reflection_resource.getEnvTypeReflectionsPath;
+exports.getSecretsDefaultTypeDefinition = require_create_reflection_resource.getSecretsDefaultTypeDefinition;
+exports.loadEnv = require_create_reflection_resource.loadEnv;
+exports.loadEnvFromContext = require_create_reflection_resource.loadEnvFromContext;
+exports.mergeEnvReflections = require_create_reflection_resource.mergeEnvReflections;
+exports.mergeSecretsReflections = require_create_reflection_resource.mergeSecretsReflections;
 exports.plugin = plugin;
-exports.readEnvReflection = require_persistence.readEnvReflection;
-exports.readEnvTypeReflection = require_persistence.readEnvTypeReflection;
-exports.readSecretsReflection = require_persistence.readSecretsReflection;
-exports.reflectEnv = require_reflect.reflectEnv;
-exports.reflectSecrets = require_reflect.reflectSecrets;
-exports.removeEnvPrefix = require_source_file_env.removeEnvPrefix;
-exports.resolveRuntimeTypeFile = require_persistence.resolveRuntimeTypeFile;
-exports.writeEnvReflection = require_persistence.writeEnvReflection;
-exports.writeEnvReflectionSync = require_persistence.writeEnvReflectionSync;
-exports.writeEnvTypeReflection = require_persistence.writeEnvTypeReflection;
+exports.readEnvReflection = require_create_reflection_resource.readEnvReflection;
+exports.readEnvTypeReflection = require_create_reflection_resource.readEnvTypeReflection;
+exports.readSecretsReflection = require_create_reflection_resource.readSecretsReflection;
+exports.reflectEnv = require_create_reflection_resource.reflectEnv;
+exports.reflectSecrets = require_create_reflection_resource.reflectSecrets;
+exports.removeEnvPrefix = require_create_reflection_resource.removeEnvPrefix;
+exports.resolveRuntimeTypeFile = require_create_reflection_resource.resolveRuntimeTypeFile;
+exports.writeEnvReflection = require_create_reflection_resource.writeEnvReflection;
+exports.writeEnvReflectionSync = require_create_reflection_resource.writeEnvReflectionSync;
+exports.writeEnvTypeReflection = require_create_reflection_resource.writeEnvTypeReflection;