@romaintaillandier1978/dotenv-never-lies 1.1.1 → 1.3.0

package/dist/infer/helpers.js

@@ -0,0 +1,41 @@
+import { zStringGenSchema } from "./generated/basic.js";
+import { LIST_RULES } from "./index.js";
+export const inferSimpleSchemaForListItem = (rawValue) => {
+    for (const rule of LIST_RULES) {
+        const result = rule.tryInfer({ name: "", rawValue });
+        if (!result)
+            continue;
+        if (result.confidence >= rule.threshold) {
+            return result.generated;
+        }
+    }
+    return zStringGenSchema;
+};
+const tokenizeEnvName = (name) => name.toUpperCase().split(/[_\-]/);
+export const matchesEnvKey = (name, keys) => {
+    const tokens = tokenizeEnvName(name);
+    // si au moins un des marker est contenu dans le nom (tokenisé et uppercasé.)
+    for (const key of keys) {
+        if (tokens.includes(key.toUpperCase())) {
+            return { matched: true, reason: `Env name contains key: ${key}` };
+        }
+    }
+    return { matched: false, reason: "No hint in the Env name" };
+};
+const SECRET_KEYS = ["SECRET", "KEY", "TOKEN", "PASSWORD", "PASS", "AUTH"];
+export const guessSecret = (name) => {
+    return matchesEnvKey(name, SECRET_KEYS).matched;
+};
+export const areAllSameGenSchemas = (elements) => {
+    const e0 = elements[0];
+    return elements.every((e) => areSameGenSchemas(e, e0));
+};
+export const areSameGenSchemas = (a, b) => {
+    if (a === b)
+        return true;
+    if (a.code !== b.code)
+        return false;
+    if (a.imports.length !== b.imports.length)
+        return false;
+    return a.imports.every((i) => b.imports.some((j) => i.name === j.name && i.from === j.from));
+};

package/dist/infer/index.d.ts

@@ -0,0 +1,4 @@
+import { InferRule } from "./types.js";
+export declare const RULES: InferRule[];
+export declare const LIST_RULES: InferRule[];
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/infer/index.ts"],"names":[],"mappings":"AASA,OAAO,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAOvC,eAAO,MAAM,KAAK,EAAE,SAAS,EAeY,CAAC;AAE1C,eAAO,MAAM,UAAU,EAAE,SAAS,EAMO,CAAC"}

package/dist/infer/index.js

@@ -0,0 +1,35 @@
+import { booleanRule } from "./rules/boolean.js";
+import { durationRule } from "./rules/duration.js";
+import { jsonRule } from "./rules/json.js";
+import { keyValueListRule, keyValueRule, listRule } from "./rules/list.js";
+import { portRule } from "./rules/port.js";
+import { emailRule, numberRule, stringRule } from "./rules/basic.js";
+import { urlRule } from "./rules/url.js";
+import { ipRule } from "./rules/ip.js";
+import { versionRule } from "./rules/version.js";
+// ⚠️ Règle d’or :
+// JSON avant list,
+// duration avant number,
+// boolean avant enum,
+export const RULES = [
+    jsonRule, // 10
+    keyValueListRule, // 9
+    keyValueRule, // 8
+    listRule, // 7
+    portRule, //7
+    durationRule, // 6
+    booleanRule, // 6
+    ipRule, // 5.5
+    versionRule, // 5
+    urlRule, // 5
+    emailRule, // 4
+    numberRule, // 3
+    stringRule, // 0 = fallback
+].sort((a, b) => b.priority - a.priority);
+export const LIST_RULES = [
+    portRule, //7
+    urlRule, //5
+    emailRule, //4
+    numberRule, //3
+    stringRule, //0
+].sort((a, b) => b.priority - a.priority);

package/dist/infer/rules/basic.d.ts

@@ -0,0 +1,11 @@
+import { InferRule } from "../types.js";
+/**
+ * Infers a number schema from a raw value. match vlaue like 42, "42", -1000, +7e6, etc.
+ * @param name - The name of the environment variable.
+ * @param rawValue - The raw value of the environment variable.
+ * @returns The inferred number schema.
+ */
+export declare const numberRule: InferRule;
+export declare const emailRule: InferRule;
+export declare const stringRule: InferRule;
+//# sourceMappingURL=basic.d.ts.map

package/dist/infer/rules/basic.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"basic.d.ts","sourceRoot":"","sources":["../../../src/infer/rules/basic.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAMxC;;;;;GAKG;AACH,eAAO,MAAM,UAAU,EAAE,SAmCxB,CAAC;AAIF,eAAO,MAAM,SAAS,EAAE,SAsBvB,CAAC;AAEF,eAAO,MAAM,UAAU,EAAE,SA0BxB,CAAC"}

package/dist/infer/rules/basic.js

@@ -0,0 +1,90 @@
+import { zEmailGenSchema, zNumberGenSchema, zStringGenSchema } from "../generated/basic.js";
+import { matchesEnvKey } from "../helpers.js";
+const NUMBER_KEYS = ["NUMBER", "NUM", "NB", "COUNT", "SIZE", "LENGTH", "RATE", "PRICE", "COST", "TOTAL", "SUM", "AVG", "MIN", "MAX"];
+/**
+ * Infers a number schema from a raw value. match vlaue like 42, "42", -1000, +7e6, etc.
+ * @param name - The name of the environment variable.
+ * @param rawValue - The raw value of the environment variable.
+ * @returns The inferred number schema.
+ */
+export const numberRule = {
+    type: "number",
+    priority: 4,
+    threshold: 5,
+    tryInfer({ name, rawValue }) {
+        let candidate = rawValue;
+        // We decided that number schema is coercive (z.coerce.number()),
+        // so we accept quotes "42" or '42', but no empty string "", '', '   '.
+        // note that number('   ') returns 0, which is not what we want
+        // never happen via dotenv, but migth happen via process.env
+        if (candidate === "" || candidate === "''" || candidate === '""')
+            return null;
+        if ((candidate.startsWith('"') && candidate.endsWith('"')) || (candidate.startsWith("'") && candidate.endsWith("'")))
+            candidate = candidate.slice(1, -1);
+        // never happen via dotenv, but migth happen via process.env
+        if (candidate.trim().match(/^\s*$/))
+            return null;
+        const n = Number(+candidate);
+        if (Number.isNaN(n))
+            return null;
+        let confidence = 5;
+        const reasons = ["Numeric value"];
+        const { matched, reason } = matchesEnvKey(name, NUMBER_KEYS);
+        if (matched) {
+            confidence += 1;
+            reasons.push(`${reason} (+1)`);
+        }
+        return {
+            generated: zNumberGenSchema,
+            confidence,
+            reasons,
+        };
+    },
+};
+const EMAIL_KEYS = ["EMAIL", "MAIL"];
+export const emailRule = {
+    type: "email",
+    priority: 4,
+    threshold: 5,
+    tryInfer({ name, rawValue }) {
+        if (!/^[^@]+@[^@]+\.[^@]+$/.test(rawValue))
+            return null;
+        let confidence = 6;
+        const reasons = ["Email-like value"];
+        const { matched, reason } = matchesEnvKey(name, EMAIL_KEYS);
+        if (matched) {
+            confidence += 1;
+            reasons.push(`${reason} (+1)`);
+        }
+        return {
+            generated: zEmailGenSchema,
+            confidence,
+            reasons,
+        };
+    },
+};
+export const stringRule = {
+    type: "string",
+    priority: 0,
+    threshold: 0,
+    tryInfer({ rawValue }) {
+        const reasons = [];
+        const warnings = [];
+        // never happen via dotenv, but migth happen via process.env
+        if (rawValue === "" || rawValue === "''" || rawValue === '""') {
+            warnings.push(" ⚠️ Inferred string was detected as an empty string, may indicate optional variable of any type");
+        }
+        else {
+            const containsOnlyBlank = rawValue.match(/^\s+$/);
+            if (containsOnlyBlank) {
+                warnings.push(" ⚠️ Inferred string was detected as containing only blank spaces, may indicate optional variable of any type");
+            }
+        }
+        return {
+            generated: zStringGenSchema,
+            confidence: 0,
+            reasons: [...reasons, "Fallback to string"],
+            warnings,
+        };
+    },
+};

package/dist/infer/rules/boolean.d.ts

@@ -0,0 +1,3 @@
+import { InferRule } from "../types.js";
+export declare const booleanRule: InferRule;
+//# sourceMappingURL=boolean.d.ts.map

package/dist/infer/rules/boolean.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"boolean.d.ts","sourceRoot":"","sources":["../../../src/infer/rules/boolean.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAMxC,eAAO,MAAM,WAAW,EAAE,SAoBzB,CAAC"}

package/dist/infer/rules/boolean.js

@@ -0,0 +1,25 @@
+import { looksLikeValidBoolean } from "../../schemas/boolean.js";
+import { matchesEnvKey } from "../helpers.js";
+import { boolGenSchema } from "../generated/boolean.js";
+const BOOLEAN_KEYS = ["IS", "HAS", "ENABLE", "DISABLE", "ENABLED", "DISABLED", "ALLOW", "DENY"];
+export const booleanRule = {
+    type: "boolean",
+    priority: 6,
+    threshold: 5,
+    tryInfer({ name, rawValue }) {
+        if (!looksLikeValidBoolean(rawValue))
+            return null;
+        let confidence = 6; // valeur bool = signal fort
+        const reasons = ["Value matches strict boolean format"];
+        const { matched, reason } = matchesEnvKey(name, BOOLEAN_KEYS);
+        if (matched) {
+            confidence += 1;
+            reasons.push(`${reason} (+1)`);
+        }
+        return {
+            generated: boolGenSchema(name),
+            confidence,
+            reasons,
+        };
+    },
+};

package/dist/infer/rules/duration.d.ts

@@ -0,0 +1,3 @@
+import { InferRule } from "../types.js";
+export declare const durationRule: InferRule;
+//# sourceMappingURL=duration.d.ts.map

package/dist/infer/rules/duration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"duration.d.ts","sourceRoot":"","sources":["../../../src/infer/rules/duration.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAMxC,eAAO,MAAM,YAAY,EAAE,SAsB1B,CAAC"}

package/dist/infer/rules/duration.js

@@ -0,0 +1,25 @@
+import { looksLikeValidDuration } from "../../schemas/duration.js";
+import { matchesEnvKey } from "../helpers.js";
+import { durationGenSchema } from "../generated/duration.js";
+const DURATION_KEYS = ["TIMEOUT", "TTL", "DELAY", "DURATION", "INTERVAL"];
+export const durationRule = {
+    type: "duration",
+    priority: 6,
+    threshold: 5,
+    tryInfer({ name, rawValue }) {
+        if (!looksLikeValidDuration(rawValue))
+            return null;
+        let confidence = 6;
+        const reasons = ["Value matches strict duration format"];
+        const { matched, reason } = matchesEnvKey(name, DURATION_KEYS);
+        if (matched) {
+            confidence += 1;
+            reasons.push(`${reason} (+1)`);
+        }
+        return {
+            generated: durationGenSchema(name),
+            confidence,
+            reasons,
+        };
+    },
+};

package/dist/infer/rules/ip.d.ts

@@ -0,0 +1,3 @@
+import { InferRule } from "../types.js";
+export declare const ipRule: InferRule;
+//# sourceMappingURL=ip.d.ts.map

package/dist/infer/rules/ip.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ip.d.ts","sourceRoot":"","sources":["../../../src/infer/rules/ip.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAIxC,eAAO,MAAM,MAAM,EAAE,SAsBpB,CAAC"}

package/dist/infer/rules/ip.js

@@ -0,0 +1,25 @@
+import { looksLikeIp } from "../../schemas/dotted.js";
+import { ipGenSchema } from "../generated/ip.js";
+import { matchesEnvKey } from "../helpers.js";
+const IP_KEYS = ["IP", "ADDRESS", "HOST", "HOSTNAME"];
+export const ipRule = {
+    type: "ip",
+    priority: 5.5,
+    threshold: 5,
+    tryInfer({ name, rawValue }) {
+        if (!looksLikeIp(rawValue))
+            return null;
+        let confidence = 5;
+        const reasons = ["Value matches strict ip format"];
+        const { matched, reason } = matchesEnvKey(name, IP_KEYS);
+        if (matched) {
+            confidence += 1;
+            reasons.push(`${reason} (+1)`);
+        }
+        return {
+            generated: ipGenSchema(name),
+            confidence,
+            reasons,
+        };
+    },
+};

package/dist/infer/rules/json.d.ts

@@ -0,0 +1,3 @@
+import { InferRule } from "../types.js";
+export declare const jsonRule: InferRule;
+//# sourceMappingURL=json.d.ts.map

package/dist/infer/rules/json.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"json.d.ts","sourceRoot":"","sources":["../../../src/infer/rules/json.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAOxC,eAAO,MAAM,QAAQ,EAAE,SAuDtB,CAAC"}

package/dist/infer/rules/json.js

@@ -0,0 +1,59 @@
+import { matchesEnvKey } from "../helpers.js";
+import { jsonGenSchema } from "../generated/json.js";
+import { zArrayOfUnknownGenSchema, zUnknownGenSchema } from "../generated/basic.js";
+const JSON_KEYS_HIGH = ["JSON"];
+const JSON_KEYS_LOW = ["PAYLOAD", "CONFIG", "DATA", "META"];
+export const jsonRule = {
+    type: "json",
+    priority: 10,
+    threshold: 5,
+    tryInfer({ name, rawValue }) {
+        let parsed;
+        // trim the raw value to avoid issues with leading or trailing spaces
+        // never happen via dotenv, but migth happen via process.env
+        if (rawValue === "" || rawValue === "''" || rawValue === '""')
+            return null;
+        const trimedRawValue = rawValue.trim();
+        const reasons = [];
+        try {
+            parsed = JSON.parse(trimedRawValue);
+        }
+        catch {
+            return null;
+        }
+        let confidence = 0;
+        // if no {} or [], we end up with a single value, like "\"romain\"" or "\"2\"". (with quotes)
+        // This would be a valid JSON, but very unlikely to be intentional.
+        if (trimedRawValue.startsWith("{") || trimedRawValue.startsWith("[")) {
+            // strong JSON structure (+6)
+            confidence += 6;
+            reasons.push("JSON structure (+6)");
+        }
+        else {
+            // JSON primitive : valid but suspicious (+2)
+            confidence += 2;
+            reasons.push("JSON primitive (+2)");
+        }
+        const { matched: matchedHigh, reason: reasonHigh } = matchesEnvKey(name, JSON_KEYS_HIGH);
+        if (matchedHigh) {
+            confidence += 2;
+            reasons.push(`${reasonHigh} (+2)`);
+        }
+        const { matched: matchedLow, reason: reasonLow } = matchesEnvKey(name, JSON_KEYS_LOW);
+        if (matchedLow) {
+            confidence += 1;
+            reasons.push(`${reasonLow} (+1)`);
+        }
+        const isArray = trimedRawValue.startsWith("[") && trimedRawValue.endsWith("]");
+        return {
+            generated: jsonGenSchema(name, isArray ? zArrayOfUnknownGenSchema : zUnknownGenSchema),
+            confidence,
+            reasons,
+            warnings: [
+                isArray
+                    ? " ⚠️ Inferred string was detected as containing a json array, please think to complete the 'of' parameter of the jsonSchema"
+                    : " ⚠️ Inferred string was detected as containing a json object, please think to complete the 'of' parameter of the jsonSchema",
+            ],
+        };
+    },
+};

package/dist/infer/rules/list.d.ts

@@ -0,0 +1,12 @@
+import { InferRule } from "../types.js";
+export declare const keyValueListRule: InferRule;
+export declare const keyValueRule: InferRule;
+/**
+ * Infers a list schema from a raw value. Infer using ';' and ','.
+ * if ';' and ',' are used, ';' has priority.
+ * @param name - The name of the list.
+ * @param rawValue - The raw value of the list.
+ * @returns The inferred list schema.
+ */
+export declare const listRule: InferRule;
+//# sourceMappingURL=list.d.ts.map

package/dist/infer/rules/list.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"list.d.ts","sourceRoot":"","sources":["../../../src/infer/rules/list.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAQxC,eAAO,MAAM,gBAAgB,EAAE,SA+E9B,CAAC;AAIF,eAAO,MAAM,YAAY,EAAE,SAsB1B,CAAC;AAIF;;;;;;GAMG;AACH,eAAO,MAAM,QAAQ,EAAE,SAkHtB,CAAC"}

package/dist/infer/rules/list.js

@@ -0,0 +1,221 @@
+import { areAllSameGenSchemas, areSameGenSchemas, inferSimpleSchemaForListItem } from "../helpers.js";
+import { matchesEnvKey } from "../helpers.js";
+import { keyValueListSchemaGen, listSchemaGen, urlListSchemaGen, emailListSchemaGen, keyValueSchemaGen, listOfSchemaGen } from "../generated/list.js";
+import { portGenSchemaNoName } from "../generated/port.js";
+import { zEmailGenSchema, zNumberGenSchema, zUrlGenSchema } from "../generated/basic.js";
+const KEY_PAIR_NAMES_LIST = ["MAPS", "LABELS", "HEADERS", "PARAMS"];
+export const keyValueListRule = {
+    type: "keyValueList",
+    priority: 9,
+    threshold: 6,
+    tryInfer({ name, rawValue }) {
+        const pairsType1 = rawValue.split(";");
+        const pairsType2 = rawValue.split(",");
+        const pairsType3 = rawValue.split("&");
+        const hasType1 = pairsType1.length > 1;
+        const hasType2 = pairsType2.length > 1;
+        const hasType3 = pairsType3.length > 1;
+        if (hasType1 && hasType2 && hasType3)
+            return null;
+        let confidence = 2;
+        const reasons = [];
+        let pairs = [];
+        if (hasType1) {
+            pairs = pairsType1;
+            confidence += 2;
+            reasons.push("Multiple pairs separated by semicolon ';' (+2)");
+            if (hasType2 || hasType3) {
+                confidence -= 1;
+                reasons.push("Semicolon has priority over comma and &, but comma and & detected, possible bad separator identified (-1)");
+            }
+        }
+        else if (hasType2) {
+            pairs = pairsType2;
+            confidence += 2;
+            reasons.push("Multiple pairs separated by comma ',' (+2)");
+            if (hasType3) {
+                confidence -= 1;
+                reasons.push("Comma has priority over &, but & detected, possible bad separator identified (-1)");
+            }
+        }
+        else if (hasType3) {
+            pairs = pairsType3;
+            confidence += 2;
+            reasons.push("Multiple pairs separated by '&' (+2)");
+        }
+        // no pairs found
+        if (pairs.length < 1)
+            return null;
+        let validPairs1 = 0;
+        let validPairs2 = 0;
+        // TODO pairs must have all the same type of separator (= or :)
+        for (const pair of pairs) {
+            if (pair.includes("="))
+                validPairs1++;
+            if (pair.includes(":"))
+                validPairs2++;
+        }
+        if (validPairs1 !== pairs.length && validPairs2 !== pairs.length)
+            return null;
+        if (validPairs1 === pairs.length) {
+            confidence += 2;
+            reasons.push("All pairs are key=value pairs (+2)");
+            if (validPairs2 === pairs.length) {
+                confidence -= 1;
+                reasons.push("Both key=value and key:value pairs detected, possible bad separator identified (-1)");
+            }
+        }
+        else if (validPairs2 === pairs.length) {
+            confidence += 2;
+            reasons.push("All pairs are key:value pairs (+2)");
+        }
+        const { matched, reason } = matchesEnvKey(name, KEY_PAIR_NAMES_LIST);
+        if (matched) {
+            confidence += 1;
+            reasons.push(`${reason} (+1)`);
+        }
+        return {
+            generated: keyValueListSchemaGen(name),
+            confidence,
+            reasons,
+        };
+    },
+};
+const KEY_PAIR_NAMES = ["ENV", "VARS", "CONFIG", "OPTIONS"];
+export const keyValueRule = {
+    type: "keyValue",
+    priority: 8,
+    threshold: 5,
+    tryInfer({ name, rawValue }) {
+        if (!rawValue.includes("=") && !rawValue.includes(":"))
+            return null;
+        const reasons = ["Single key=value or key:value structure"];
+        let confidence = 4;
+        const { matched, reason } = matchesEnvKey(name, KEY_PAIR_NAMES);
+        if (matched) {
+            confidence += 1;
+            reasons.push(`${reason} (+1)`);
+        }
+        return {
+            generated: keyValueSchemaGen(name),
+            confidence,
+            reasons,
+        };
+    },
+};
+const LIST_KEYS = ["LIST", "ITEMS", "ARRAY", "VALUES"];
+/**
+ * Infers a list schema from a raw value. Infer using ';' and ','.
+ * if ';' and ',' are used, ';' has priority.
+ * @param name - The name of the list.
+ * @param rawValue - The raw value of the list.
+ * @returns The inferred list schema.
+ */
+export const listRule = {
+    type: "list",
+    priority: 7,
+    threshold: 5,
+    tryInfer({ name, rawValue }) {
+        const semicolonItems = rawValue.split(";");
+        const commaItems = rawValue.split(",");
+        let parts = [];
+        let confidence = 0;
+        const reasons = [];
+        const warnings = [];
+        const hasSemicolon = semicolonItems.length > 1;
+        const hasComma = commaItems.length > 1;
+        const isOnlyEmptyList = /^;+$/.test(rawValue) || /^,+$/.test(rawValue);
+        if (isOnlyEmptyList) {
+            warnings.push(" ⚠️ Inferred list was detected as containing only empty values, consider completing the 'of' parameter of the listSchema");
+        }
+        if (hasSemicolon) {
+            confidence += 4;
+            reasons.push("multiple values separated by semicolon ';' (+4)");
+            parts = semicolonItems;
+            if (hasComma) {
+                confidence -= 1;
+                reasons.push("semicolon has priority over comma, but comma detected, possible bad separator identified (-1)");
+            }
+        }
+        else if (hasComma) {
+            confidence += 4;
+            reasons.push("multiple values separated by comma ',' (+4)");
+            parts = commaItems;
+        }
+        if (!parts || parts.length === 0)
+            return null;
+        const { matched, reason } = matchesEnvKey(name, LIST_KEYS);
+        if (matched) {
+            confidence += 1;
+            reasons.push(`${reason} (+1)`);
+        }
+        const itemTypes = parts.map((value) => inferSimpleSchemaForListItem(value));
+        // if some elements are of different types => list of strings.
+        if (!areAllSameGenSchemas(itemTypes)) {
+            return {
+                generated: listSchemaGen(name),
+                confidence,
+                reasons,
+                warnings,
+            };
+        }
+        // from here, all elements are of the same type => we can generate a typed list
+        reasons.push("All elements are of the same type (+2)");
+        confidence += 2;
+        // List of ports
+        if (areSameGenSchemas(itemTypes[0], portGenSchemaNoName)) {
+            reasons.push("All elements are PORTS (+2)");
+            confidence += 2;
+            return {
+                generated: listOfSchemaGen(name, itemTypes[0]),
+                confidence,
+                reasons,
+                warnings,
+            };
+        }
+        // List of emails
+        if (areSameGenSchemas(itemTypes[0], zEmailGenSchema)) {
+            reasons.push("All elements are emails (+2)");
+            confidence += 2;
+            return {
+                generated: emailListSchemaGen(name),
+                confidence,
+                reasons,
+                warnings,
+            };
+        }
+        // here we assume we have a list of simple URLs.
+        // possible evolution with all types of URLs.
+        // List of URLs
+        if (areSameGenSchemas(itemTypes[0], zUrlGenSchema)) {
+            reasons.push("All elements are URLs (+2)");
+            confidence += 2;
+            return {
+                generated: urlListSchemaGen(name),
+                confidence,
+                reasons,
+                warnings,
+            };
+        }
+        // List of numbers
+        if (areSameGenSchemas(itemTypes[0], zNumberGenSchema)) {
+            reasons.push("All elements are numbers (+2)");
+            confidence += 2;
+            return {
+                generated: listOfSchemaGen(name, itemTypes[0]),
+                confidence,
+                reasons,
+                warnings,
+            };
+        }
+        // List of strings
+        reasons.push("All elements are strings (+2)");
+        confidence += 2;
+        return {
+            generated: listSchemaGen(name),
+            confidence,
+            reasons,
+            warnings,
+        };
+    },
+};

package/dist/infer/rules/port.d.ts

@@ -0,0 +1,3 @@
+import { InferRule } from "../types.js";
+export declare const portRule: InferRule;
+//# sourceMappingURL=port.d.ts.map

package/dist/infer/rules/port.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"port.d.ts","sourceRoot":"","sources":["../../../src/infer/rules/port.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAMxC,eAAO,MAAM,QAAQ,EAAE,SA4BtB,CAAC"}

package/dist/infer/rules/port.js

@@ -0,0 +1,30 @@
+import { matchesEnvKey } from "../helpers.js";
+import { portGenSchema } from "../generated/port.js";
+const PORT_KEYS = ["PORT", "PORT", "PORT"];
+export const portRule = {
+    type: "port",
+    priority: 7,
+    threshold: 5,
+    tryInfer({ name, rawValue }) {
+        // reject floats, versions (2.0), weird numbers
+        if (!/^\d+$/.test(rawValue)) {
+            return null;
+        }
+        const port = Number(rawValue);
+        if (!Number.isInteger(port) || port < 1 || port > 65535) {
+            return null;
+        }
+        let confidence = 5; // valeur seule = déjà crédible
+        const reasons = ["Valid TCP/UDP port number"];
+        const { matched, reason } = matchesEnvKey(name, PORT_KEYS);
+        if (matched) {
+            confidence += 2;
+            reasons.push(`${reason} (+2)`);
+        }
+        return {
+            generated: portGenSchema(name),
+            confidence,
+            reasons,
+        };
+    },
+};

package/dist/infer/rules/url.d.ts

@@ -0,0 +1,4 @@
+import { InferRule } from "../types.js";
+export declare const URL_KEYS: string[];
+export declare const urlRule: InferRule;
+//# sourceMappingURL=url.d.ts.map

package/dist/infer/rules/url.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"url.d.ts","sourceRoot":"","sources":["../../../src/infer/rules/url.ts"],"names":[],"mappings":"AASA,OAAO,EAAgC,SAAS,EAAE,MAAM,aAAa,CAAC;AAKtE,eAAO,MAAM,QAAQ,EAAE,MAAM,EAAyF,CAAC;AA8EvH,eAAO,MAAM,OAAO,EAAE,SA8ErB,CAAC"}