@romaintaillandier1978/dotenv-never-lies 0.3.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Romain TAILLANDIER
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,319 @@
+# dotenv-never-lies
+
+> Parce que les variables d’environnement **mentent tout le temps**.
+
+**dotenv-never-lies** valide, type et documente tes variables d’environnement à partir d’un schéma TypeScript / Zod.  
+Il échoue **vite**, **fort**, et **avant la prod**.
+
+---
+
+## Pourquoi ?
+
+Parce que tout ça arrive **tout le temps** :
+
+- ❌ une variable d’env manquante → **crash au runtime**
+- ❌ une URL mal formée → **bug subtil en prod**
+- ❌ la CI n’a pas été mise à jour après une nouvelle variable → **déploiement rouge incompréhensible**
+- ❌ un `process.env.FOO!` optimiste → **mensonge à toi-même**
+
+Et parce que `.env` est :
+
+- non typé
+- non documenté
+- partagé à la main
+- rarement à jour
+
+👉 **dotenv-never-lies** transforme cette configuration fragile en **contrat explicite**.
+
+---
+
+## Ce que fait la lib
+
+- ✅ valide les variables d’environnement au démarrage
+- ✅ fournit un typage TypeScript fiable
+- ✅ documente chaque variable
+- ✅ expose un CLI pour la CI et les humains
+- ✅ permet des transformations complexes (arrays, parsing, coercion…)
+
+---
+
+## Ce que dotenv-never-lies n’est pas
+
+Ce package a un périmètre volontairement **limité**.
+
+- ❌ **Ce n’est pas un outil frontend**  
+  Il n’est pas destiné à être utilisé dans un navigateur.  
+  Pas de bundler, pas de `import.meta.env`, pas de variables exposées au client.
+
+- ❌ **Ce n’est pas un gestionnaire de secrets**  
+  Il ne chiffre rien, ne stocke rien, ne remplace ni Vault, ni AWS Secrets Manager,
+  ni les variables sécurisées de ton provider CI/CD.
+
+- ❌ **Ce n’est pas une solution cross-runtime**  
+  Support ciblé : **Node.js**.  
+  Deno, Bun, Cloudflare Workers, edge runtimes : hors scope (pour l’instant).
+
+- ❌ **Ce n’est pas un framework de configuration global**  
+  Il ne gère ni les fichiers YAML/JSON, ni les profiles dynamiques,
+  ni les overrides magiques par environnement.
+
+- ❌ **Ce n’est pas permissif**  
+  S’il manque une variable ou qu’une valeur est invalide, ça plante.  
+  C’est le but.
+
+En résumé :  
+**dotenv-never-lies** est fait pour des **APIs Node.js** et des **services backend**  
+qui préfèrent **échouer proprement au démarrage** plutôt que **bugger silencieusement en prod**.
+
+---
+
+## Dependency warnings
+
+⚠️ Important
+dotenv-never-lies expose des schémas Zod dans son API publique.
+Zod v4 est requis.
+Mélanger les versions cassera l’inférence de types (et oui, ça fait mal).
+
+## Installation
+
+```bash
+yarn add dotenv-never-lies
+# ou
+npm install dotenv-never-lies
+```
+
+## Expansion des variables (`dotenv-expand`)
+
+**dotenv-never-lies** gère automatiquement l’expansion des variables d’environnement,
+via [`dotenv-expand`](https://www.npmjs.com/package/dotenv-expand).
+
+Cela permet de définir des variables composées à partir d’autres variables,
+sans duplication ni copier-coller fragile.
+
+### Exemple
+
+```env
+FRONT_A=https://a.site.com
+FRONT_B=https://b.site.com
+FRONT_C=https://c.site.com
+
+NODE_CORS_ORIGIN="${FRONT_A};${FRONT_B};${FRONT_C}"
+```
+
+## Définir un schéma
+
+env.dnl.ts
+
+```typescript
+import { z } from "zod";
+import { define } from "dotenv-never-lies";
+
+export default define({
+    NODE_ENV: {
+        description: "Environnement d’exécution",
+        schema: z.enum(["test", "development", "staging", "production"]),
+    },
+
+    NODE_PORT: {
+        description: "Port de l’API",
+        schema: z.coerce.number(),
+    },
+
+    FRONT_A: {
+        description: "Mon site A",
+        schema: z.url(),
+    },
+
+    FRONT_B: {
+        description: "Mon site B",
+        schema: z.url(),
+    },
+
+    FRONT_C: {
+        description: "Mon site C",
+        schema: z.url(),
+    },
+
+    NODE_CORS_ORIGIN: {
+        description: "URLs frontend autorisées à appeler cette API",
+        schema: z.string().transform((v) =>
+            v
+                .split(";")
+                .map((s) => s.trim())
+                .filter(Boolean)
+                .map((url) => z.url().parse(url))
+        ),
+    },
+
+    JWT_SECRET: {
+        description: "JWT Secret",
+        schema: z.string(),
+        secret: true,
+    },
+});
+```
+
+## Utilisation runtime
+
+```typescript
+import envDef from "./env.dnl";
+
+export const ENV = envDef.load();
+
+if(ENV.NODE_ENV === "test"){...}
+
+
+```
+
+Résultat :
+
+- ENV.NODE_ENV est un enum
+- ENV.NODE_PORT est un number
+- ENV.FRONT_A ENV.FRONT_B ENV.FRONT_C sont des URLs valides
+- ENV.NODE_CORS_ORIGIN est un string[] contenant des URLs valides
+- ENV.JWT_SECRET est une string
+
+Si une variable est absente ou invalide → le process s’arrête immédiatement. \
+C’est volontaire.
+
+## Éviter `process.env` dans le code applicatif
+
+Une fois le schéma chargé, l’accès aux variables d’environnement
+doit se faire exclusivement via l’objet `ENV`.
+
+Cela garantit :
+
+- un typage strict
+- des valeurs validées
+- un point d’entrée unique pour la configuration
+
+Pour identifier les usages résiduels de `process.env` dans votre codebase, un simple outil de recherche suffit :
+
+```bash
+grep -R "process\.env" src
+```
+
+Le choix de corriger (ou non) ces usages dépend du contexte et reste volontairement laissé au développeur.
+
+## CLI
+
+Le CLI permet de valider, charger, générer et documenter les variables d’environnement à partir d’un schéma `dotenv-never-lies`.
+
+Il est conçu pour être utilisé :
+
+- en local (par des humains)
+- en CI (sans surprise)
+- avant que l’application ne démarre (et pas après)
+
+### Valider un fichier `.env` (CI-friendly)
+
+Valide les variables sans les injecter dans `process.env`.
+
+```bash
+dnl check --schema env.dnl.ts
+```
+
+→ échoue si :
+
+- une variable est manquante
+- une valeur est invalide
+- le schéma n’est pas respecté
+
+### Charger les variables dans le process
+
+Charge et valide les variables dans `process.env`.
+
+```bash
+dnl load --schema env.dnl.ts
+```
+
+Usage typique : scripts de démarrage, tooling local.
+
+### Générer un fichier .env à partir du schéma
+
+Génère un .env documenté à partir du schéma.
+
+```bash
+dnl generate --schema env.dnl.ts --out .env
+```
+
+Utile pour :
+
+- initialiser un projet
+- partager un template
+- éviter les .env.example obsolètes
+
+### Générer un schéma depuis un .env existant
+
+Crée un fichier env.dnl.ts à partir d’un .env.
+
+```bash
+dnl reverse-env --source .env
+```
+
+Utile pour :
+
+- migrer un projet existant
+- documenter a posteriori une configuration legacy
+
+### Afficher la documentation des variables
+
+Affiche la liste des variables connues et leur description.
+
+```bash
+dnl print
+```
+
+Exemple de sortie :
+
+```bash
+FRONT_A: Mon site A
+FRONT_B: Mon site B
+FRONT_C: Mon site C
+NODE_CORS_ORIGIN: URLs frontend autorisées à appeler cette API
+JWT_SECRET: JWT Secret
+
+```
+
+TODO : check CI in real life.
+
+## Usages dans la vraie vie
+
+### Git
+
+#### Git hooks recommandés
+
+Il est fortement conseillé d’utiliser **dotenv-never-lies** via des hooks Git :
+
+- **pre-commit** : empêche de committer si la configuration locale n’est pas conforme au schéma
+- **post-merge** : détecte immédiatement les changements de schéma impactant l’environnement local
+
+L’objectif est simple :  
+**si la configuration locale n’est pas conforme au schéma, le code ne doit pas être committé.**
+
+Le schéma est la source de vérité, pas les fichiers `.env`.
+
+Ces hooks permettent d’éviter les erreurs classiques :
+
+- variable manquante après un pull
+- format invalide détecté trop tard
+- “ça marche chez moi” dû à un `.env` obsolète
+
+#### Installation des hooks
+
+```bash
+git config core.hooksPath .githooks
+mkdir -p .githooks
+
+cat > .githooks/pre-commit <<'EOF'
+#!/bin/sh
+yarn dnl assert --source .env
+EOF
+
+cat > .githooks/post-merge <<'EOF'
+#!/bin/sh
+yarn dnl assert --source .env || true
+EOF
+
+chmod +x .githooks/pre-commit .githooks/post-merge
+```

package/dist/DnlTest.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=DnlTest.d.ts.map

package/dist/DnlTest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DnlTest.d.ts","sourceRoot":"","sources":["../src/DnlTest.ts"],"names":[],"mappings":""}

package/dist/DnlTest.js

@@ -0,0 +1,12 @@
+export {};
+//envDefinition.explain({ key: "NODE_CORS_ORIGIN" });
+// const source: EnvSource = dnl.readEnvFile(".env");
+// let ok = envDefinition.check();
+// ok = envDefinition.check({ source: process.env });
+// const ENV = envDefinition.load({ source });
+// ok = envDefinition.check();
+// ok = envDefinition.check({ source: process.env });
+// // intellisens OK
+// ENV.NODE_ENV; //(property) NODE_ENV: "test" | "development" | "staging" | "production"
+// ENV.NODE_PORT; //(property) NODE_PORT: number
+// envDefinition.explain();

package/dist/cli/commands/assert.d.ts

@@ -0,0 +1,5 @@
+export declare const assertCommand: (opts: {
+    schema: string;
+    source: string;
+}) => Promise<void>;
+//# sourceMappingURL=assert.d.ts.map

package/dist/cli/commands/assert.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"assert.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/assert.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,aAAa,GAAU,MAAM;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,kBAwB3E,CAAC"}

package/dist/cli/commands/assert.js

@@ -0,0 +1,27 @@
+import path from "node:path";
+import dnl from "../../index.js";
+import { loadDef as loadDef } from "../utils/load-schema.js";
+import { resolveSchemaPath } from "../utils/resolve-schema.js";
+import { z } from "zod";
+export const assertCommand = async (opts) => {
+    const schemaPath = resolveSchemaPath(opts.schema);
+    const envDef = (await loadDef(schemaPath));
+    try {
+        envDef.assert({
+            source: opts.source ? dnl.readEnvFile(path.resolve(process.cwd(), opts.source)) : process.env,
+        });
+        console.log("✅ Environment is valid");
+    }
+    catch (error) {
+        if (error instanceof z.ZodError) {
+            console.error("❌ Invalid environment variables:\n");
+            for (const issue of error.issues) {
+                const key = issue.path.join(".");
+                console.error(`- ${key}`);
+                console.error(`  → ${issue.message}`);
+            }
+            process.exit(1);
+        }
+        throw error;
+    }
+};

package/dist/cli/commands/explain.d.ts

@@ -0,0 +1,8 @@
+type ExplainCliOptions = {
+    schema?: string | undefined;
+    keys?: string[] | undefined;
+    format?: "human" | "json" | undefined;
+};
+export declare const explainCommand: (options?: ExplainCliOptions) => Promise<number>;
+export {};
+//# sourceMappingURL=explain.d.ts.map

package/dist/cli/commands/explain.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"explain.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/explain.ts"],"names":[],"mappings":"AAKA,KAAK,iBAAiB,GAAG;IACrB,MAAM,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC5B,IAAI,CAAC,EAAE,MAAM,EAAE,GAAG,SAAS,CAAC;IAC5B,MAAM,CAAC,EAAE,OAAO,GAAG,MAAM,GAAG,SAAS,CAAC;CACzC,CAAC;AAEF,eAAO,MAAM,cAAc,GAAU,UAAU,iBAAiB,KAAG,OAAO,CAAC,MAAM,CAmChF,CAAC"}

package/dist/cli/commands/explain.js

@@ -0,0 +1,55 @@
+import { loadDef } from "../utils/load-schema.js";
+import { resolveSchemaPath } from "../utils/resolve-schema.js";
+import { toExplanation } from "../utils/printer.js";
+export const explainCommand = async (options) => {
+    const schemaPath = resolveSchemaPath(options?.schema);
+    const envDef = (await loadDef(schemaPath));
+    const format = options?.format ?? "human";
+    const keysToSerialize = new Array();
+    if (options?.keys) {
+        keysToSerialize.push(...options.keys);
+    }
+    const result = new Array();
+    for (const [key, value] of Object.entries(envDef.def)) {
+        if (keysToSerialize.length > 0 && !keysToSerialize.includes(key)) {
+            continue;
+        }
+        result.push(toExplanation(key, value));
+    }
+    if (result.length === 0) {
+        console.error("No variables found");
+        return 1;
+    }
+    switch (format) {
+        case "json":
+            console.log(JSON.stringify(result, null, 2));
+            return 0;
+        case "human":
+            printHuman(result);
+            return 0;
+        default:
+            console.error(`Invalid format: ${format}`);
+            return 1;
+    }
+};
+const printHuman = (result) => {
+    if (result.length > 1) {
+        for (const item of result) {
+            console.log(`${item.key}: ${item.description}  --- dnl explain ${item.key} --format human  for more details`);
+        }
+        return;
+    }
+    console.log(`${result[0].key}:`);
+    console.log(`   Description: ${result[0].description}`);
+    console.log(`   Type: ${result[0].type}`);
+    if (result[0].required !== undefined) {
+        console.log(`   Required: ${result[0].required ? "Yes" : "No"}`);
+    }
+    if (result[0].default !== undefined) {
+        console.log(`   Default: ${result[0].default ?? "No"}`);
+    }
+    console.log(`   Secret: ${result[0].secret === true ? "Yes" : "No"}`);
+    if (result[0].examples) {
+        console.log(`   Examples: ${result[0].examples.join(", ")}`);
+    }
+};

package/dist/cli/commands/generate.d.ts

@@ -0,0 +1,7 @@
+export declare const generateCommand: (opts: {
+    schema?: string;
+    out?: string;
+    includeSecret?: boolean;
+    force?: boolean;
+}) => Promise<void>;
+//# sourceMappingURL=generate.d.ts.map

package/dist/cli/commands/generate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/generate.ts"],"names":[],"mappings":"AAOA,eAAO,MAAM,eAAe,GAAU,MAAM;IAAE,MAAM,CAAC,EAAE,MAAM,CAAC;IAAC,GAAG,CAAC,EAAE,MAAM,CAAC;IAAC,aAAa,CAAC,EAAE,OAAO,CAAC;IAAC,KAAK,CAAC,EAAE,OAAO,CAAA;CAAE,kBA4BtH,CAAC"}

package/dist/cli/commands/generate.js

@@ -0,0 +1,28 @@
+import fs from "node:fs";
+import path from "node:path";
+import { loadDef } from "../utils/load-schema.js";
+import { resolveSchemaPath } from "../utils/resolve-schema.js";
+import { getDefaultEnvValue } from "../utils/printer.js";
+export const generateCommand = async (opts) => {
+    const outFile = opts.out ?? ".env";
+    const target = path.resolve(process.cwd(), outFile);
+    if (fs.existsSync(target) && !opts.force) {
+        console.error(`❌ ${outFile} already exists. Use --force to overwrite.`);
+        process.exit(1);
+    }
+    const schemaPath = resolveSchemaPath(opts.schema);
+    const envDef = (await loadDef(schemaPath));
+    const lines = [];
+    for (const [key, def] of Object.entries(envDef.def)) {
+        const typedDef = def;
+        if (typedDef.description) {
+            lines.push(`# ${typedDef.description}`);
+        }
+        const defaultValue = getDefaultEnvValue(typedDef.schema.def);
+        lines.push(`${key}=${defaultValue ?? ""}`);
+        lines.push(""); // blank line
+    }
+    const output = lines.join("\n");
+    fs.writeFileSync(target, output);
+    console.log(`✅ ${outFile} generated`);
+};

package/dist/cli/commands/reverseEnv.d.ts

@@ -0,0 +1,7 @@
+export declare const reverseEnvCommand: (opts: {
+    source?: string;
+    out?: string;
+    force?: boolean;
+    guessSecret?: boolean;
+}) => Promise<void>;
+//# sourceMappingURL=reverseEnv.d.ts.map

package/dist/cli/commands/reverseEnv.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reverseEnv.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/reverseEnv.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,iBAAiB,GAAU,MAAM;IAAE,MAAM,CAAC,EAAE,MAAM,CAAC;IAAC,GAAG,CAAC,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,OAAO,CAAC;IAAC,WAAW,CAAC,EAAE,OAAO,CAAA;CAAE,kBAiCtH,CAAC"}

package/dist/cli/commands/reverseEnv.js

@@ -0,0 +1,33 @@
+import path from "node:path";
+import dnl from "../../index.js";
+import { guessSecret, inferSchema } from "../utils/infer-schema.js";
+import fs from "node:fs";
+export const reverseEnvCommand = async (opts) => {
+    const source = path.resolve(process.cwd(), opts.source ?? ".env");
+    const out = opts.out ?? "env.dnl.ts";
+    const target = path.resolve(process.cwd(), out);
+    if (fs.existsSync(target) && !opts.force) {
+        console.error(`❌ ${out} already exists. Use --force to overwrite.`);
+        process.exit(1);
+    }
+    const env = dnl.readEnvFile(source);
+    const lines = [];
+    lines.push(`// ⚠️ This file was generated by dotenv-never-lies`);
+    lines.push(`// Review and adjust schemas, descriptions and secrets before using`);
+    lines.push("");
+    lines.push(`import { z } from "zod";`);
+    lines.push(`import { define } from "dotenv-never-lies";`);
+    lines.push("");
+    lines.push(`export default define({`);
+    for (const [key, value] of Object.entries(env)) {
+        lines.push(`    ${key}: {`);
+        lines.push(`        description: "TODO",`);
+        lines.push(`        schema: ${inferSchema(value)},`);
+        if (opts.guessSecret && guessSecret(key)) {
+            lines.push(`        secret: true,`);
+        }
+        lines.push(`    },`);
+    }
+    lines.push(`});`);
+    fs.writeFileSync(target, lines.join("\n"));
+};

package/dist/cli/index.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/cli/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/cli/index.ts"],"names":[],"mappings":""}

package/dist/cli/index.js

@@ -0,0 +1,127 @@
+#!/usr/bin/env node
+import { program } from "commander";
+import { assertCommand } from "./commands/assert.js";
+import { generateCommand } from "./commands/generate.js";
+import { reverseEnvCommand } from "./commands/reverseEnv.js";
+import { explainCommand } from "./commands/explain.js";
+program
+    .name("dnl")
+    .version("0.1.0")
+    .addHelpText("before", `
+CLI pour dotenv-never-lies.
+Valide, charge et génère des variables d’environnement typées à partir d’un schéma TypeScript/Zod.
+      `)
+    .addHelpText("after", `\nExemples :
+        
+        # Vérifier l’environnement à l’exécution et arrêter le process si le schéma n’est pas respecté
+        dnl assert 
+        dnl assert --schema env.dnl.ts
+      
+        # Générer un fichier .env documenté à partir du schéma
+        dnl generate 
+        dnl generate --schema env.dnl.ts --out .env
+      
+        # Créer un schéma env.dnl.ts depuis un .env existant
+        dnl reverse-env --source .env
+      
+        # Afficher les variables connues et leur description
+        dnl explain
+      `);
+program
+    .command("assert")
+    .description("Vérifie l’environnement runtime et termine le process si le schéma n’est pas respecté.")
+    .option("--schema <file>", "Fichier de schéma dnl (ex: my-dnl.ts)", "env.dnl.ts")
+    .option("-s, --source <source>", "Source des variables (défaut : process.env)")
+    .action(assertCommand)
+    .addHelpText("after", `\nExemples :
+        
+        # Valider les variables d’environnement de process.env
+        # Recommandé en CI pour empêcher un démarrage avec une configuration invalide
+        dnl assert
+        dnl assert --schema my-dnl.ts
+
+        # Valider les variables d’environnement depuis un fichier .env
+        # Recommandé en local (préparation du schéma, onboarding)
+        dnl assert --source .env
+        dnl assert --schema my-dnl.ts --source .env
+
+        # valider les variables d'environnement du fichier fourni par la CI
+        dnl assert --source $ENV_FILE
+        dnl assert --schema my-dnl.ts --source $ENV_FILE
+      `);
+program
+    .command("generate")
+    .description("Génère un fichier .env à partir d’un schéma dnl.\n" +
+    "Utile pour initialiser un projet ou faciliter l’onboarding d’un nouveau développeur.\n" +
+    "Seules les valeurs définies par défaut dans le schéma sont écrites.")
+    .option("--schema <file>", "Fichier de schéma env (ex: env.dnl.ts)")
+    .option("-o, --out <file>", "Fichier de sortie (défaut : .env)")
+    .option("-f, --force", "Écraser le fichier existant")
+    .action(generateCommand)
+    .addHelpText("after", `\nExemples :
+        
+        # Générer un fichier .env à partir du schéma par défaut (env.dnl.ts)
+        dnl generate
+
+        # Générer un fichier .env à partir d'un schéma spécifié
+        dnl generate --schema my-dnl.ts
+
+        # Générer un fichier .env.local à partir du schéma
+        dnl generate --out .env.local
+
+        # Générer un fichier .env à partir d'un schéma et écraser le fichier existant
+        dnl generate --out .env --force
+      `);
+program
+    .command("reverse-env")
+    .description("Génère un schéma dotenv-never-lies à partir d’un fichier .env.\n" +
+    "Utile pour migrer un projet existant vers dotenv-never-lies.\n" +
+    "Le schéma généré est un point de départ et doit être affiné manuellement.")
+    .option("-s, --source <source>", "Fichier .env source", ".env")
+    .option("-o, --out <file>", "Fichier dnl de sortie", "env.dnl.ts")
+    .option("-f, --force", "Écraser le fichier existant")
+    .option("--guess-secret", "Tenter de deviner les variables sensibles (heuristique)")
+    .action(reverseEnvCommand)
+    .addHelpText("after", `\nExemples :
+        
+        # Générer un schéma env.dnl.ts à partir d'un fichier .env
+        dnl reverse-env
+
+        # Générer un schéma env.dnl.ts à partir d'un fichier .env.local
+        dnl reverse-env --source .env.local
+        
+        # Générer un schéma my-dnl.ts à partir d'un fichier .env
+        dnl reverse-env --out my-dnl.ts
+
+        # Générer un schéma env.dnl.ts à partir d'un fichier .env et écraser le fichier existant
+        dnl reverse-env --force
+      `);
+program
+    .command("explain")
+    .description("Affiche la liste des variables d’environnement connues et leur description.")
+    .argument("[keys...]", "Clés à expliquer (0..N). Sans argument, toutes les clés.")
+    .option("--schema <file>", "Fichier de schéma env (ex: env.dnl.ts)")
+    .option("-f, --format <format>", 'Format d\'affichage ("human" | "json")', "human")
+    .action(async (keys, opts) => {
+    const result = await explainCommand({ keys: keys ?? [], schema: opts.schema, format: opts.format });
+    process.exit(result);
+})
+    .addHelpText("after", `\nExemples :
+        
+        # expliquer toutes les variables connues et leur description
+        dnl explain
+        
+        # expliquer une variable en détail
+        dnl explain NODE_ENV
+
+        # sortie machine
+        dnl explain --format json
+
+        # expliquer toutes les variables connues et leur description à partir d'un schéma
+        dnl explain --schema another-env.ts
+       
+        # expliquer une partie des variables connues et leur description
+        dnl explain NODE_ENV NODE_PORT 
+        
+      `);
+program.parse(process.argv);

package/dist/cli/utils/infer-schema.d.ts

@@ -0,0 +1,3 @@
+export declare const inferSchema: (value: string | undefined) => "z.string().optional()" | "z.coerce.boolean()" | "z.coerce.number()" | "z.string().url()" | "z.string().email()" | "z.string()";
+export declare const guessSecret: (value: string) => boolean;
+//# sourceMappingURL=infer-schema.d.ts.map

package/dist/cli/utils/infer-schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"infer-schema.d.ts","sourceRoot":"","sources":["../../../src/cli/utils/infer-schema.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,WAAW,GAAI,OAAO,MAAM,GAAG,SAAS,oIAuBpD,CAAC;AAIF,eAAO,MAAM,WAAW,GAAI,OAAO,MAAM,YAExC,CAAC"}

package/dist/cli/utils/infer-schema.js

@@ -0,0 +1,24 @@
+export const inferSchema = (value) => {
+    if (!value) {
+        return "z.string().optional()";
+    }
+    if (/^(true|false)$/i.test(value)) {
+        return "z.coerce.boolean()";
+    }
+    if (!isNaN(Number(value))) {
+        return "z.coerce.number()";
+    }
+    try {
+        new URL(value);
+        return "z.string().url()";
+    }
+    catch { }
+    if (/^[^@]+@[^@]+\.[^@]+$/.test(value)) {
+        return "z.string().email()";
+    }
+    return "z.string()";
+};
+const secretSuffixes = ["_SECRET", "_KEY", "_TOKEN", "_PASSWORD", "_AUTH"];
+export const guessSecret = (value) => {
+    return secretSuffixes.some((suffix) => value.endsWith(suffix));
+};

package/dist/cli/utils/load-schema.d.ts

@@ -0,0 +1,3 @@
+import { EnvDefinitionHelper } from "../../core.js";
+export declare const loadDef: (schemaPath: string) => Promise<EnvDefinitionHelper<any>>;
+//# sourceMappingURL=load-schema.d.ts.map

package/dist/cli/utils/load-schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"load-schema.d.ts","sourceRoot":"","sources":["../../../src/cli/utils/load-schema.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,mBAAmB,EAAE,MAAM,eAAe,CAAC;AAEpD,eAAO,MAAM,OAAO,GAAU,YAAY,MAAM,KAAG,OAAO,CAAC,mBAAmB,CAAC,GAAG,CAAC,CAsBlF,CAAC"}

package/dist/cli/utils/load-schema.js

@@ -0,0 +1,22 @@
+import { build } from "esbuild";
+import path from "node:path";
+import fs from "node:fs/promises";
+import { pathToFileURL } from "node:url";
+export const loadDef = async (schemaPath) => {
+    const outDir = path.join(process.cwd(), ".dnl");
+    await fs.mkdir(outDir, { recursive: true });
+    const outFile = path.join(outDir, "env.dnl.mjs");
+    await build({
+        entryPoints: [schemaPath],
+        outfile: outFile,
+        format: "esm",
+        platform: "node",
+        target: "node18",
+        bundle: false,
+    });
+    const mod = await import(pathToFileURL(outFile).href);
+    if (!mod.default) {
+        throw new Error("Le fichier env.dnl.ts doit exporter un schéma par défaut (export default).");
+    }
+    return mod.default;
+};

package/dist/cli/utils/printer.d.ts

@@ -0,0 +1,16 @@
+import { z } from "zod";
+import { EnvVarDefinition } from "../../core.js";
+export type Explanation = {
+    key: string;
+    description: string;
+    type: string;
+    required?: boolean;
+    default?: string;
+    secret: boolean;
+    examples?: string[];
+};
+export declare const toExplanation: (key: string, value: EnvVarDefinition<any>) => Explanation;
+export declare function printZodType(def: z.core.$ZodTypeDef): string;
+export declare function getDefaultEnvValue(def: z.core.$ZodTypeDef): string | undefined;
+export declare function isRequired(def: z.core.$ZodTypeDef): boolean;
+//# sourceMappingURL=printer.d.ts.map

package/dist/cli/utils/printer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"printer.d.ts","sourceRoot":"","sources":["../../../src/cli/utils/printer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AAEjD,MAAM,MAAM,WAAW,GAAG;IACtB,GAAG,EAAE,MAAM,CAAC;IACZ,WAAW,EAAE,MAAM,CAAC;IACpB,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,OAAO,CAAC;IAChB,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;CACvB,CAAC;AACF,eAAO,MAAM,aAAa,GAAI,KAAK,MAAM,EAAE,OAAO,gBAAgB,CAAC,GAAG,CAAC,KAAG,WAWzE,CAAC;AAEF,wBAAgB,YAAY,CAAC,GAAG,EAAE,CAAC,CAAC,IAAI,CAAC,WAAW,GAAG,MAAM,CAoE5D;AAuBD,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,CAAC,CAAC,IAAI,CAAC,WAAW,GAAG,MAAM,GAAG,SAAS,CAwB9E;AAED,wBAAgB,UAAU,CAAC,GAAG,EAAE,CAAC,CAAC,IAAI,CAAC,WAAW,GAAG,OAAO,CAyB3D"}

package/dist/cli/utils/printer.js

@@ -0,0 +1,137 @@
+export const toExplanation = (key, value) => {
+    const def = value.schema.def;
+    return {
+        key,
+        description: value.description,
+        type: printZodType(def),
+        required: isRequired(def),
+        default: getDefaultEnvValue(def),
+        secret: value.secret === true,
+        examples: value.examples,
+    };
+};
+export function printZodType(def) {
+    switch (def.type) {
+        case "string":
+        case "number":
+        case "boolean":
+        case "transform":
+            return def.type;
+        case "enum":
+            if ("entries" in def) {
+                return Object.keys(def.entries)
+                    .map((k) => k)
+                    .join(" | ");
+            }
+            return "unknown";
+        case "literal":
+            if ("values" in def) {
+                return def.values[0].toString() + " (literal)";
+            }
+            return "unknown";
+        case "array":
+            if ("element" in def) {
+                return printZodType(def.element) + "[]";
+            }
+            return "[]";
+        case "optional":
+            if ("innerType" in def) {
+                return printZodType(def.innerType) + " | undefined";
+            }
+            return "unknown  | undefined";
+        case "nullable":
+            if ("innerType" in def) {
+                return printZodType(def.innerType) + " | null";
+            }
+            return "unknown  | null";
+        case "default":
+            if ("innerType" in def) {
+                const result = printZodType(def.innerType);
+                const defaultValue = typeof def.defaultValue === "function" ? def.defaultValue() : (def.defaultValue ?? undefined);
+                // const defaultValue = (def as any).defaultValue;
+                if (defaultValue) {
+                    return result + " (default: " + defaultValue.toString() + ")";
+                }
+                return result;
+            }
+            return "unknown  | null";
+        // z.union
+        case "union":
+            if ("options" in def) {
+                return def.options.map(printZodType).join(" | ");
+            }
+            return "unknown";
+        // z.transform
+        case "pipe": {
+            if (!("in" in def)) {
+                return "unknown (pipe)";
+            }
+            const result = printZodType(def.in);
+            return result + " (transform)";
+        }
+        default:
+            return "unknown";
+    }
+}
+function stringifyEnvValue(value) {
+    if (value === undefined || value === null) {
+        return undefined;
+    }
+    if (typeof value === "string") {
+        return value;
+    }
+    if (typeof value === "number" || typeof value === "boolean") {
+        return String(value);
+    }
+    // arrays / objects → JSON
+    try {
+        return JSON.stringify(value);
+    }
+    catch {
+        return undefined;
+    }
+}
+export function getDefaultEnvValue(def) {
+    switch (def.type) {
+        case "default": {
+            const raw = typeof def.defaultValue === "function" ? def.defaultValue() : (def.defaultValue ?? undefined);
+            return stringifyEnvValue(raw);
+        }
+        // wrappers transparents
+        case "optional":
+        case "nullable":
+            if ("innerType" in def) {
+                return getDefaultEnvValue(def.innerType);
+            }
+            return undefined;
+        case "pipe":
+            if ("in" in def) {
+                return getDefaultEnvValue(def.in);
+            }
+            return undefined;
+        default:
+            return undefined;
+    }
+}
+export function isRequired(def) {
+    switch (def.type) {
+        case "optional":
+            return false;
+        case "default":
+            return false;
+        // nullable n’enlève PAS le required
+        case "nullable":
+            if ("innerType" in def) {
+                return isRequired(def.innerType);
+            }
+            return false;
+        // pipe / transform → transparent côté required
+        case "pipe":
+            if ("in" in def) {
+                return isRequired(def.in);
+            }
+            return true;
+        default:
+            return true;
+    }
+}

package/dist/cli/utils/resolve-schema.d.ts

@@ -0,0 +1,2 @@
+export declare const resolveSchemaPath: (cliPath?: string) => string;
+//# sourceMappingURL=resolve-schema.d.ts.map

package/dist/cli/utils/resolve-schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve-schema.d.ts","sourceRoot":"","sources":["../../../src/cli/utils/resolve-schema.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,iBAAiB,GAAI,UAAU,MAAM,KAAG,MA0BpD,CAAC"}

package/dist/cli/utils/resolve-schema.js

@@ -0,0 +1,27 @@
+import fs from "node:fs";
+import path from "node:path";
+const CANDIDATES = ["env.dnl.ts", "env.dnl.js", "dnl.config.ts", "dnl.config.js"];
+export const resolveSchemaPath = (cliPath) => {
+    // 1. --schema
+    if (cliPath) {
+        return path.resolve(process.cwd(), cliPath);
+    }
+    // 2. package.json
+    const pkgPath = path.resolve(process.cwd(), "package.json");
+    if (fs.existsSync(pkgPath)) {
+        const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
+        const schema = pkg?.["dotenv-never-lies"]?.schema;
+        if (schema) {
+            return path.resolve(process.cwd(), schema);
+        }
+    }
+    // 3. convention
+    for (const file of CANDIDATES) {
+        const full = path.resolve(process.cwd(), file);
+        console.log("full", full);
+        if (fs.existsSync(full)) {
+            return full;
+        }
+    }
+    throw new Error("No env schema found. Use --schema or define one in package.json.");
+};

package/dist/core.d.ts

@@ -0,0 +1,107 @@
+import { z } from "zod";
+/**
+ * Un objet contenant les variables d'environnement sous forme de string, issue d'un fichier .env ou de process.env.
+ */
+export type EnvSource = Record<string, string | undefined>;
+/**
+ * Une variable d'environnement.
+ */
+export interface EnvVarDefinition<T extends z.ZodType = z.ZodType> {
+    /**
+     * Le schéma Zod de la variable d'environnement.
+     */
+    schema: T;
+    /**
+     * La description de la variable d'environnement.
+     */
+    description: string;
+    /**
+     * Indique si la variable d'environnement est secrète (pour les token, les mots de passe), RFU.
+     */
+    secret?: boolean;
+    /**
+     * Indique des exemple pour cette variable
+     */
+    examples?: string[];
+}
+/**
+ * Un objet contenant les variables d'environnement définies.
+ */
+export type EnvDefinition = Record<string, EnvVarDefinition<any>>;
+/**
+ * Le shape Zod du schéma d'environnement.
+ */
+export type ZodShapeFromEnv<T extends EnvDefinition> = {
+    [K in keyof T & string]: T[K]["schema"];
+};
+/**
+ * Le type inféré du schéma d'environnement.
+ */
+export type InferEnv<T extends EnvDefinition> = {
+    [K in keyof T & string]: z.infer<T[K]["schema"]>;
+};
+type CheckFn = (options?: {
+    source?: EnvSource | undefined;
+}) => boolean;
+type AssertFn<T extends EnvDefinition> = (options?: {
+    source?: EnvSource | undefined;
+}) => InferEnv<T>;
+/**
+ * Un objet contenant les fonctions pour vérifier, charger et afficher les variables d'environnement.
+ * @template T - Le schéma d'environnement à définir.
+ */
+export type EnvDefinitionHelper<T extends EnvDefinition> = {
+    /**
+     * Le schéma d'environnement défini.
+     */
+    def: T;
+    /**
+     * Le shape Zod du schéma d'environnement.
+     */
+    zodShape: ZodShapeFromEnv<T>;
+    /**
+     * Le schéma Zod du schéma d'environnement.
+     */
+    zodSchema: z.ZodObject<ZodShapeFromEnv<T>>;
+    /**
+     * Vérifie si les variables d'environnement sont valides sans lever d'exception.
+     *
+     * Si `options.source` est fourni, il est utilisé avec le mode strict (zod.strict())
+     * Si `options.source` est fourni, on utilise `process.env`, en mode non strict
+     *
+     * @param options - Les options pour vérifier les variables d'environnement.
+     * @returns true si les variables d'environnement sont valides, false sinon.
+     */
+    check: CheckFn;
+    /**
+     * Vérifie les variables d'environnement et arrête le process si elle ne sont pas conformes au schéma.
+     *
+     * Si `options.source` est fourni, il est utilisé avec le mode strict (zod.strict())
+     * Si `options.source` est fourni, on utilise `process.env`, en mode non strict
+     *
+     * @param options - Les options pour charger les variables d'environnement.
+     * @returns Les variables d'environnement chargées.
+     * @throws Si les variables d'environnement sont invalides.
+     */
+    assert: AssertFn<T>;
+};
+/**
+ * Définit un schéma d'environnement.
+ * @param def - Le schéma d'environnement à définir.
+ * @returns Un objet contenant les fonctions pour vérifier, charger et afficher les variables d'environnement.
+ */
+export declare const define: <T extends EnvDefinition>(def: T) => EnvDefinitionHelper<T>;
+/**
+ * Lit un fichier .env et retourne les variables d'environnement sous forme d'objet.
+ * Utilise dotenv et dotenv-expand.
+ * @example
+ * ```typescript
+ * const ENV = envDefinition.load({ source: readEnvFile(".env") });
+ * ```
+ * @param path - Le chemin vers le fichier .env.
+ * @returns Les variables d'environnement sous forme d'objet.
+ * @throws Si le fichier .env n'existe pas, ou n'est pas conforme
+ */
+export declare const readEnvFile: (path: string) => EnvSource;
+export {};
+//# sourceMappingURL=core.d.ts.map

package/dist/core.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"core.d.ts","sourceRoot":"","sources":["../src/core.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB;;GAEG;AACH,MAAM,MAAM,SAAS,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,CAAC;AAE3D;;GAEG;AACH,MAAM,WAAW,gBAAgB,CAAC,CAAC,SAAS,CAAC,CAAC,OAAO,GAAG,CAAC,CAAC,OAAO;IAC7D;;OAEG;IACH,MAAM,EAAE,CAAC,CAAC;IACV;;OAEG;IACH,WAAW,EAAE,MAAM,CAAC;IACpB;;OAEG;IACH,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB;;OAEG;IACH,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;CACvB;AAID;;GAEG;AACH,MAAM,MAAM,aAAa,GAAG,MAAM,CAAC,MAAM,EAAE,gBAAgB,CAAC,GAAG,CAAC,CAAC,CAAC;AAElE;;GAEG;AACH,MAAM,MAAM,eAAe,CAAC,CAAC,SAAS,aAAa,IAAI;KAClD,CAAC,IAAI,MAAM,CAAC,GAAG,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC;CAC1C,CAAC;AACF;;GAEG;AACH,MAAM,MAAM,QAAQ,CAAC,CAAC,SAAS,aAAa,IAAI;KAC3C,CAAC,IAAI,MAAM,CAAC,GAAG,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC;CACnD,CAAC;AAEF,KAAK,OAAO,GAAG,CAAC,OAAO,CAAC,EAAE;IAAE,MAAM,CAAC,EAAE,SAAS,GAAG,SAAS,CAAA;CAAE,KAAK,OAAO,CAAC;AACzE,KAAK,QAAQ,CAAC,CAAC,SAAS,aAAa,IAAI,CAAC,OAAO,CAAC,EAAE;IAAE,MAAM,CAAC,EAAE,SAAS,GAAG,SAAS,CAAA;CAAE,KAAK,QAAQ,CAAC,CAAC,CAAC,CAAC;AAEvG;;;GAGG;AACH,MAAM,MAAM,mBAAmB,CAAC,CAAC,SAAS,aAAa,IAAI;IACvD;;OAEG;IACH,GAAG,EAAE,CAAC,CAAC;IACP;;OAEG;IACH,QAAQ,EAAE,eAAe,CAAC,CAAC,CAAC,CAAC;IAC7B;;OAEG;IACH,SAAS,EAAE,CAAC,CAAC,SAAS,CAAC,eAAe,CAAC,CAAC,CAAC,CAAC,CAAC;IAC3C;;;;;;;;OAQG;IACH,KAAK,EAAE,OAAO,CAAC;IACf;;;;;;;;;OASG;IACH,MAAM,EAAE,QAAQ,CAAC,CAAC,CAAC,CAAC;CACvB,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,MAAM,GAAI,CAAC,SAAS,aAAa,EAAE,KAAK,CAAC,KAAG,mBAAmB,CAAC,CAAC,CAuB7E,CAAC;AAEF;;;;;;;;;;GAUG;AACH,eAAO,MAAM,WAAW,GAAI,MAAM,MAAM,KAAG,SAa1C,CAAC"}

package/dist/core.js

@@ -0,0 +1,53 @@
+import { z } from "zod";
+import dotenv from "dotenv";
+import dotenvExpand from "dotenv-expand";
+import { EnvFileNotFoundError } from "./errors.js";
+import fs from "fs";
+/**
+ * Définit un schéma d'environnement.
+ * @param def - Le schéma d'environnement à définir.
+ * @returns Un objet contenant les fonctions pour vérifier, charger et afficher les variables d'environnement.
+ */
+export const define = (def) => {
+    const zodShape = Object.fromEntries(Object.entries(def).map(([key, value]) => [key, value.schema]));
+    const zodSchema = z.object(zodShape);
+    const strictSchema = zodSchema.strict();
+    const extractParams = (options) => {
+        const source = options?.source ?? process.env;
+        const strict = source !== process.env;
+        return { source, strict };
+    };
+    const getSchema = (strict) => (strict ? strictSchema : zodSchema);
+    const check = (options) => {
+        const { source, strict } = extractParams(options);
+        return getSchema(strict).safeParse(source).success;
+    };
+    const assert = (options) => {
+        const { source, strict } = extractParams(options);
+        return getSchema(strict).parse(source);
+    };
+    return { def, zodShape, zodSchema, check, assert };
+};
+/**
+ * Lit un fichier .env et retourne les variables d'environnement sous forme d'objet.
+ * Utilise dotenv et dotenv-expand.
+ * @example
+ * ```typescript
+ * const ENV = envDefinition.load({ source: readEnvFile(".env") });
+ * ```
+ * @param path - Le chemin vers le fichier .env.
+ * @returns Les variables d'environnement sous forme d'objet.
+ * @throws Si le fichier .env n'existe pas, ou n'est pas conforme
+ */
+export const readEnvFile = (path) => {
+    if (!fs.existsSync(path)) {
+        throw new EnvFileNotFoundError(path);
+    }
+    const content = fs.readFileSync(path);
+    const parsed = dotenv.parse(content);
+    dotenvExpand.expand({
+        processEnv: {}, // important, else, process.env is mutated
+        parsed,
+    });
+    return parsed;
+};

package/dist/errors.d.ts

@@ -0,0 +1,4 @@
+export declare class EnvFileNotFoundError extends Error {
+    constructor(path: string);
+}
+//# sourceMappingURL=errors.d.ts.map

package/dist/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAAA,qBAAa,oBAAqB,SAAQ,KAAK;gBAC/B,IAAI,EAAE,MAAM;CAI3B"}

package/dist/errors.js

@@ -0,0 +1,6 @@
+export class EnvFileNotFoundError extends Error {
+    constructor(path) {
+        super(`Env file not found: ${path}`);
+        this.name = "EnvFileNotFoundError";
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+import * as dnl from "./core.js";
+export * from "./core.js";
+export { dnl };
+export default dnl;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,GAAG,MAAM,WAAW,CAAC;AASjC,cAAc,WAAW,CAAC;AAC1B,OAAO,EAAE,GAAG,EAAE,CAAC;AACf,eAAe,GAAG,CAAC"}

package/dist/index.js

@@ -0,0 +1,8 @@
+import * as dnl from "./core.js";
+import { z } from "zod";
+if (!("ZodFirstPartyTypeKind" in z)) {
+    throw new Error("dotenv-never-lies requires Zod v4+. Detected an incompatible Zod version. " + "This library exposes Zod schemas as part of its public API.");
+}
+export * from "./core.js";
+export { dnl };
+export default dnl;

package/package.json

@@ -0,0 +1,72 @@
+{
+    "name": "@romaintaillandier1978/dotenv-never-lies",
+    "version": "0.3.0",
+    "description": "Typed, validated, and explicit environment variables — powered by Zod.",
+    "license": "MIT",
+    "author": "Romain TAILLANDIER",
+    "type": "module",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/romaintaillandier1978/dotenv-never-lies"
+    },
+    "keywords": [
+        "env",
+        "environment",
+        "dotenv",
+        "configuration",
+        "zod",
+        "validation",
+        "typesafe",
+        "cli"
+    ],
+    "engines": {
+        "node": ">=18.0.0"
+    },
+    "files": [
+        "dist",
+        "README.md",
+        "LICENSE"
+    ],
+    "main": "dist/index.js",
+    "types": "dist/index.d.ts",
+    "exports": {
+        ".": {
+            "types": "./dist/index.d.ts",
+            "import": "./dist/index.js"
+        },
+        "./cli": {
+            "types": "./dist/cli/index.d.ts",
+            "import": "./dist/cli/index.js"
+        }
+    },
+    "bin": {
+        "dnl": "./dist/cli/index.js"
+    },
+    "scripts": {
+        "build": "tsc",
+        "prepublishOnly": "npm test && npm run build",
+        "test": "yarn build &&  node dist/DnlTest.js",
+        "dev": "tsx src/cli/index.ts",
+        "devold": "yarn build && node dist/cli/index.js",
+        "gen": "rm -rf dist; rm dotenv-never-lies-v*.tgz; yarn build && yarn pack"
+    },
+    "peerDependencies": {
+        "zod": ">=4.2.1"
+    },
+    "dependencies": {
+        "commander": "^14.0.2",
+        "dotenv": "^17.2.3",
+        "dotenv-expand": "^12.0.3",
+        "esbuild": "^0.27.2",
+        "tsx": "^4.21.0"
+    },
+    "devDependencies": {
+        "@types/node": "^25.0.3",
+        "@typescript-eslint/eslint-plugin": "^8.50.0",
+        "@typescript-eslint/parser": "^8.50.0",
+        "eslint": "^9.39.2",
+        "prettier": "^3.7.4",
+        "typescript": "^5.9.3",
+        "zod": "^4.2.1"
+    }
+}