@agnostack/env 2.0.0-canary.2 → 2.0.0-canary.3

package/CHANGELOG.md

@@ -1,3 +1,15 @@
+# [2.0.0-canary.3](https://github.com/[secure]/env/compare/v2.0.0-canary.2...v2.0.0-canary.3) (2026-08-28)
+
+
+### Bug Fixes
+
+* updated to test pin appName derivation on the first hyphen and override ([d83c6b5](https://github.com/[secure]/env/commit/d83c6b5c41d2a4b7135bfa8dd7dad65b083f2805))
+
+
+### Features
+
+* return argEntries so callers can forward what they did not consume ([b9dba14](https://github.com/[secure]/env/commit/b9dba140330bb2684f91911512556bbcd355942a))
+
 # [2.0.0-canary.2](https://github.com/[secure]/env/compare/v2.0.0-canary.1...v2.0.0-canary.2) (2026-08-16)
 
 

package/dist/env.d.ts

@@ -10,21 +10,21 @@ export function lowerKeyValidator(envKey: string): boolean;
 export function publicKeyValidator(envKey: string): boolean;
 export function cleanLowerEnv(_env: Record<string, string | undefined> | undefined, keyValidator?: (envKey: string) => boolean): Record<string, string | undefined>;
 export function cleanPublicEnv(_env: Record<string, string | undefined> | undefined, keyValidator?: (envKey: string) => boolean): Record<string, string | undefined>;
-export function parseEnvData(_env?: NodeJS.ProcessEnv): {
+export function parseEnvData(_env?: Record<string, string | undefined>): {
+    args: string[];
     env: Record<string, string> & {
         ENVIRONMENT: string;
     };
     nextEnv: Record<string, string | undefined>;
     publicEnv: Record<string, string | undefined>;
     stringifiedEnv: Record<string, string>;
-    argParams: {
-        [x: string]: string | undefined;
-    };
-    params: {
-        [x: string]: string | undefined;
-        ENVIRONMENT: string;
-    };
-    args: string[];
+    argEntries: {
+        arg: string;
+        param: string;
+        value: string | undefined;
+    }[];
+    argParams: Record<string, string | undefined>;
+    params: Record<string, string | undefined>;
 };
 export function getPublicEnvValue(publicEnv: Record<string, string | undefined> | undefined, key: string): string | undefined;
 export function replaceEnvTemplate(replaceable: unknown, { env: _env, template, callback, }?: {

package/dist/env.js

@@ -61,6 +61,39 @@ exports.cleanLowerEnv = cleanLowerEnv;
  */
 const cleanPublicEnv = (_env, keyValidator = exports.publicKeyValidator) => (cleanEnv(_env, keyValidator));
 exports.cleanPublicEnv = cleanPublicEnv;
+/**
+ * The one place argv and the ambient env are read together, so a caller gets both from a single
+ * call rather than parsing argv itself.
+ *
+ * ENVIRONMENT is resolved rather than trusted: an explicit `ENVIRONMENT` wins, otherwise the first
+ * non-empty of SITE_ENV, BUILD_ENV, NODE_ENV, falling back to 'development'.
+ *
+ * ⚠️ The argv split is by FORM, not by meaning. `--key=value` becomes an `argParams` entry; a
+ * valueless `--flag` stays a string in `args`, which also still holds `process.argv[0]` (the node
+ * binary) and `[1]` (the script path). A caller reading positionals must skip those two, and one
+ * reading bare flags must look in `args` rather than `argParams`.
+ *
+ * `argEntries` is the third view: every argument in order — `arg` as typed, `param` and `value`
+ * already split out — so a
+ * caller can forward what it did not consume without re-deriving it. An ARRAY rather than a map
+ * because repeats are meaningful — `--context=a=1 --context=b=2` is two entries, and keying them
+ * would silently keep only the last.
+ *
+ * `stringifiedEnv` is a MAP, not a string — each value JSON-stringified, which is the shape
+ * webpack's DefinePlugin wants.
+ *
+ * @param {Record<string, string | undefined>} [_env]  defaults to process.env
+ * @returns {{
+ *   args: string[],
+ *   env: Record<string, string> & { ENVIRONMENT: string },
+ *   nextEnv: Record<string, string | undefined>,
+ *   publicEnv: Record<string, string | undefined>,
+ *   stringifiedEnv: Record<string, string>,
+ *   argEntries: { arg: string, param: string, value: string | undefined }[],
+ *   argParams: Record<string, string | undefined>,
+ *   params: Record<string, string | undefined>,
+ * }}
+ */
 const parseEnvData = (_env = process.env) => {
     var _a;
     const { ENVIRONMENT, SITE_ENV, BUILD_ENV, NODE_ENV } = _env;
@@ -73,7 +106,10 @@ const parseEnvData = (_env = process.env) => {
     const mergedEnv = Object.assign(Object.assign({}, _env), { 
         // NOTE: intentionally giving precedence to ENVIRONMENT
         ENVIRONMENT: ENVIRONMENT || _environment });
-    const _b = process.argv.reduce(({ args: _args, argParams: _argParams, }, arg) => {
+    // NOTE: One pass over argv building both halves of the split — `args` collects every entry that
+    // carried no value (bare flags, positionals, and argv[0]/[1]), `argParams` every `key=value` one
+    // with its leading `--` stripped. An entry is never in both.
+    const _b = process.argv.reduce(({ args: _args, argParams: _argParams, argEntries: _argEntries, }, arg, index) => {
         var _a, _b, _c, _d, _e;
         // NOTE: split on the FIRST '=' only — everything after it is the value, verbatim.
         // Splitting on every '=' truncated any value that contained one, so `--context=env=prod`
@@ -87,6 +123,7 @@ const parseEnvData = (_env = process.env) => {
             return {
                 args: _args,
                 argParams: _argParams,
+                argEntries: _argEntries,
             };
         }
         /** @type {[string, string | undefined]} */
@@ -108,10 +145,20 @@ const parseEnvData = (_env = process.env) => {
             argParams: Object.assign(Object.assign({}, _argParams), (0, display_js_1.stringNotEmptyOnly)(value) && {
                 [param]: value,
             }),
+            // NOTE: index 0 is the node binary and 1 the script path — never arguments, so neither
+            // reaches argEntries. That is what lets a caller forward `arg` without re-deriving which
+            // entries were real arguments.
+            argEntries: [
+                ..._argEntries,
+                ...(index >= 2) ? [{ arg, param, value }] : []
+            ],
         };
     }, {
         args: /** @type {string[]} */ ([]),
-        argParams: /** @type {Record<string, string>} */ ({}),
+        // NOTE: `string | undefined` because the conditional spread below can widen it — seeding it
+        // as `Record<string, string>` made the accumulator and the callback's return disagree.
+        argParams: /** @type {Record<string, string | undefined>} */ ({}),
+        argEntries: /** @type {{ arg: string, param: string, value: string | undefined }[]} */ ([]),
     }), { argParams } = _b, output = __rest(_b, ["argParams"]);
     const nextEnv = cleanEnv(mergedEnv);
     const publicEnv = (0, exports.cleanPublicEnv)(mergedEnv);

package/dist/esm/env.js

@@ -53,6 +53,39 @@ export const cleanLowerEnv = (_env, keyValidator = lowerKeyValidator) => (cleanE
  * @returns {Record<string, string | undefined>}
  */
 export const cleanPublicEnv = (_env, keyValidator = publicKeyValidator) => (cleanEnv(_env, keyValidator));
+/**
+ * The one place argv and the ambient env are read together, so a caller gets both from a single
+ * call rather than parsing argv itself.
+ *
+ * ENVIRONMENT is resolved rather than trusted: an explicit `ENVIRONMENT` wins, otherwise the first
+ * non-empty of SITE_ENV, BUILD_ENV, NODE_ENV, falling back to 'development'.
+ *
+ * ⚠️ The argv split is by FORM, not by meaning. `--key=value` becomes an `argParams` entry; a
+ * valueless `--flag` stays a string in `args`, which also still holds `process.argv[0]` (the node
+ * binary) and `[1]` (the script path). A caller reading positionals must skip those two, and one
+ * reading bare flags must look in `args` rather than `argParams`.
+ *
+ * `argEntries` is the third view: every argument in order — `arg` as typed, `param` and `value`
+ * already split out — so a
+ * caller can forward what it did not consume without re-deriving it. An ARRAY rather than a map
+ * because repeats are meaningful — `--context=a=1 --context=b=2` is two entries, and keying them
+ * would silently keep only the last.
+ *
+ * `stringifiedEnv` is a MAP, not a string — each value JSON-stringified, which is the shape
+ * webpack's DefinePlugin wants.
+ *
+ * @param {Record<string, string | undefined>} [_env]  defaults to process.env
+ * @returns {{
+ *   args: string[],
+ *   env: Record<string, string> & { ENVIRONMENT: string },
+ *   nextEnv: Record<string, string | undefined>,
+ *   publicEnv: Record<string, string | undefined>,
+ *   stringifiedEnv: Record<string, string>,
+ *   argEntries: { arg: string, param: string, value: string | undefined }[],
+ *   argParams: Record<string, string | undefined>,
+ *   params: Record<string, string | undefined>,
+ * }}
+ */
 export const parseEnvData = (_env = process.env) => {
     var _a;
     const { ENVIRONMENT, SITE_ENV, BUILD_ENV, NODE_ENV } = _env;
@@ -65,7 +98,10 @@ export const parseEnvData = (_env = process.env) => {
     const mergedEnv = Object.assign(Object.assign({}, _env), { 
         // NOTE: intentionally giving precedence to ENVIRONMENT
         ENVIRONMENT: ENVIRONMENT || _environment });
-    const _b = process.argv.reduce(({ args: _args, argParams: _argParams, }, arg) => {
+    // NOTE: One pass over argv building both halves of the split — `args` collects every entry that
+    // carried no value (bare flags, positionals, and argv[0]/[1]), `argParams` every `key=value` one
+    // with its leading `--` stripped. An entry is never in both.
+    const _b = process.argv.reduce(({ args: _args, argParams: _argParams, argEntries: _argEntries, }, arg, index) => {
         var _a, _b, _c, _d, _e;
         // NOTE: split on the FIRST '=' only — everything after it is the value, verbatim.
         // Splitting on every '=' truncated any value that contained one, so `--context=env=prod`
@@ -79,6 +115,7 @@ export const parseEnvData = (_env = process.env) => {
             return {
                 args: _args,
                 argParams: _argParams,
+                argEntries: _argEntries,
             };
         }
         /** @type {[string, string | undefined]} */
@@ -100,10 +137,20 @@ export const parseEnvData = (_env = process.env) => {
             argParams: Object.assign(Object.assign({}, _argParams), stringNotEmptyOnly(value) && {
                 [param]: value,
             }),
+            // NOTE: index 0 is the node binary and 1 the script path — never arguments, so neither
+            // reaches argEntries. That is what lets a caller forward `arg` without re-deriving which
+            // entries were real arguments.
+            argEntries: [
+                ..._argEntries,
+                ...(index >= 2) ? [{ arg, param, value }] : []
+            ],
         };
     }, {
         args: /** @type {string[]} */ ([]),
-        argParams: /** @type {Record<string, string>} */ ({}),
+        // NOTE: `string | undefined` because the conditional spread below can widen it — seeding it
+        // as `Record<string, string>` made the accumulator and the callback's return disagree.
+        argParams: /** @type {Record<string, string | undefined>} */ ({}),
+        argEntries: /** @type {{ arg: string, param: string, value: string | undefined }[]} */ ([]),
     }), { argParams } = _b, output = __rest(_b, ["argParams"]);
     const nextEnv = cleanEnv(mergedEnv);
     const publicEnv = cleanPublicEnv(mergedEnv);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agnostack/env",
-  "version": "2.0.0-canary.2",
+  "version": "2.0.0-canary.3",
   "author": "agnoStack Dev <developers@agnostack.com> (https://agnostack.com)",
   "owner": "agnoStack",
   "description": "Please contact agnoStack via info@agnostack.com for any questions",