@ayronforge/envil 0.6.0 → 0.7.2

package/dist/index.js

@@ -197,6 +197,11 @@ function buildEnv(opts) {
   return env;
 }
 function createEnv(opts) {
+  if (process.env.ENVIL_INTROSPECT_ONLY === "1") {
+    return new Proxy({}, { get: () => {
+      return;
+    } });
+  }
   if (opts.resolvers?.length) {
     const shouldAutoRedact = opts.autoRedactResolver !== false;
     return Effect.all(opts.resolvers, { concurrency: "unbounded" }).pipe(Effect.map((results) => {
@@ -225,6 +230,577 @@ function createEnv(opts) {
   }
   return buildEnv(opts);
 }
+// src/introspect.ts
+import { Option, Redacted as Redacted2, Schema as Schema4, SchemaAST } from "effect";
+
+// src/cli/dotenv-codec.ts
+import { Schema as Schema2 } from "effect";
+
+// src/cli/literals.ts
+function toCodeLiteral(value) {
+  if (typeof value === "string")
+    return JSON.stringify(value);
+  if (typeof value === "number" || typeof value === "boolean")
+    return String(value);
+  if (value === null)
+    return "null";
+  if (value === undefined)
+    return "undefined";
+  return JSON.stringify(value);
+}
+function toEnvValueLiteral(value) {
+  if (typeof value === "string")
+    return value;
+  if (typeof value === "number" || typeof value === "boolean")
+    return String(value);
+  if (value === null || value === undefined)
+    return "";
+  return JSON.stringify(value);
+}
+function parseBooleanDirective(value, defaultValue) {
+  if (value === undefined || value.length === 0) {
+    return defaultValue;
+  }
+  const normalized = value.trim().toLowerCase();
+  if (normalized === "true")
+    return true;
+  if (normalized === "false")
+    return false;
+  throw new Error(`Invalid boolean directive value "${value}"`);
+}
+
+// src/cli/types.ts
+var BUCKETS = ["server", "client", "shared"];
+var SCHEMA_KINDS = [
+  "requiredString",
+  "boolean",
+  "integer",
+  "number",
+  "port",
+  "url",
+  "postgresUrl",
+  "redisUrl",
+  "mongoUrl",
+  "mysqlUrl",
+  "commaSeparated",
+  "commaSeparatedNumbers",
+  "commaSeparatedUrls",
+  "json",
+  "stringEnum"
+];
+var FRAMEWORKS = ["nextjs", "vite", "expo", "nuxt", "sveltekit", "astro"];
+
+// src/cli/dotenv-codec.ts
+var SENTINEL_DIRECTIVE_PREFIX = "@";
+var KEY_ASSIGNMENT_PATTERN = /^([A-Za-z_][A-Za-z0-9_]*)\s*=(.*)$/;
+var DotenvCodec = Schema2.transform(Schema2.String, Schema2.Unknown, {
+  decode: (text) => parseDotenvText(String(text)),
+  encode: (value) => stringifyDotenvDocument(value)
+});
+function decodeDotenvText(text) {
+  return Schema2.decodeUnknownSync(DotenvCodec)(text);
+}
+function encodeDotenvText(document) {
+  return Schema2.encodeSync(DotenvCodec)(document);
+}
+function parseDotenvText(text) {
+  const lines = text.split(/\r?\n/);
+  const entries = [];
+  const prefix = {};
+  let activeBucket;
+  let pendingDirectives = {};
+  for (const [index, line] of lines.entries()) {
+    const lineNumber = index + 1;
+    const trimmed = line.trim();
+    if (trimmed.length === 0) {
+      continue;
+    }
+    if (trimmed.startsWith("#")) {
+      const comment = trimmed.slice(1).trim();
+      if (comment.startsWith(SENTINEL_DIRECTIVE_PREFIX)) {
+        const directiveResult = parseDirectiveGroup(comment, lineNumber, pendingDirectives);
+        if (directiveResult.sectionBucket) {
+          activeBucket = directiveResult.sectionBucket;
+          if (directiveResult.sectionPrefix) {
+            prefix[directiveResult.sectionBucket] = directiveResult.sectionPrefix;
+          }
+          pendingDirectives = {};
+        } else {
+          pendingDirectives = directiveResult.directives;
+        }
+      }
+      continue;
+    }
+    const assignmentMatch = KEY_ASSIGNMENT_PATTERN.exec(trimmed);
+    if (!assignmentMatch) {
+      throw new Error(`Malformed assignment at line ${lineNumber}: "${line}"`);
+    }
+    const key = assignmentMatch[1];
+    const rightHandSide = assignmentMatch[2];
+    const split = splitValueAndInlineComment(rightHandSide);
+    const value = normalizeAssignedValue(split.value.trim());
+    let directives = { ...pendingDirectives };
+    if (split.comment) {
+      const inlineComment = split.comment.trim();
+      if (inlineComment.startsWith(SENTINEL_DIRECTIVE_PREFIX)) {
+        const parsedInline = parseDirectiveGroup(inlineComment, lineNumber, directives);
+        if (parsedInline.sectionBucket) {
+          throw new Error(`Section directives are not allowed inline at line ${lineNumber}`);
+        }
+        directives = parsedInline.directives;
+      }
+    }
+    entries.push({
+      key,
+      value,
+      line: lineNumber,
+      sectionBucket: activeBucket,
+      directives
+    });
+    pendingDirectives = {};
+  }
+  const hasPrefix = Object.values(prefix).some((v) => v && v.length > 0);
+  return { entries, ...hasPrefix ? { prefix } : {} };
+}
+function stringifyDotenvDocument(document) {
+  if (!document || !Array.isArray(document.entries)) {
+    throw new Error("Invalid dotenv document: expected an entries array");
+  }
+  const grouped = {
+    server: [],
+    client: [],
+    shared: []
+  };
+  const sortedEntries = [...document.entries].sort((left, right) => {
+    if (left.line !== right.line)
+      return left.line - right.line;
+    return left.key.localeCompare(right.key);
+  });
+  for (const entry of sortedEntries) {
+    const bucket = entry.directives.bucket ?? entry.sectionBucket ?? "server";
+    grouped[bucket].push(entry);
+  }
+  const lines = [];
+  for (const bucket of BUCKETS) {
+    const pfx = document.prefix?.[bucket];
+    lines.push(pfx && pfx.length > 0 ? `# @${bucket} ${pfx}` : `# @${bucket}`);
+    lines.push("");
+    for (const entry of grouped[bucket]) {
+      const optional = entry.directives.optional ?? false;
+      const redacted = entry.directives.redacted ?? false;
+      const noDefault = entry.directives.hasDefault === false;
+      if (entry.directives.type === "stringEnum" && entry.directives.stringEnumValues) {
+        lines.push(`# @type enum ${entry.directives.stringEnumValues.join(",")}`);
+      }
+      if (optional)
+        lines.push("# @optional");
+      if (noDefault)
+        lines.push("# @no-default");
+      if (redacted)
+        lines.push("# @redacted");
+      lines.push(`${entry.key}=${serializeEnvValue(entry.value)}`);
+      lines.push("");
+    }
+  }
+  while (lines.length > 0 && lines[lines.length - 1] === "") {
+    lines.pop();
+  }
+  return `${lines.join(`
+`)}
+`;
+}
+function splitValueAndInlineComment(value) {
+  let inSingleQuote = false;
+  let inDoubleQuote = false;
+  let escaped = false;
+  for (let index = 0;index < value.length; index += 1) {
+    const char = value[index];
+    if (escaped) {
+      escaped = false;
+      continue;
+    }
+    if (char === "\\") {
+      escaped = true;
+      continue;
+    }
+    if (char === "'" && !inDoubleQuote) {
+      inSingleQuote = !inSingleQuote;
+      continue;
+    }
+    if (char === '"' && !inSingleQuote) {
+      inDoubleQuote = !inDoubleQuote;
+      continue;
+    }
+    if (!inSingleQuote && !inDoubleQuote && char === "#") {
+      return {
+        value: value.slice(0, index).trimEnd(),
+        comment: value.slice(index + 1)
+      };
+    }
+  }
+  return { value };
+}
+function parseDirectiveGroup(directiveText, lineNumber, base) {
+  const directives = { ...base };
+  const tokens = directiveText.split(/\s+(?=@)/g).map((token) => token.trim()).filter(Boolean);
+  let sectionBucket;
+  let sectionPrefix;
+  for (const token of tokens) {
+    const parsed = parseDirectiveToken(token, lineNumber);
+    if ("type" in parsed)
+      directives.type = parsed.type;
+    if ("optional" in parsed)
+      directives.optional = parsed.optional;
+    if ("hasDefault" in parsed)
+      directives.hasDefault = parsed.hasDefault;
+    if ("redacted" in parsed)
+      directives.redacted = parsed.redacted;
+    if ("bucket" in parsed)
+      directives.bucket = parsed.bucket;
+    if ("stringEnumValues" in parsed)
+      directives.stringEnumValues = parsed.stringEnumValues;
+    if ("sectionBucket" in parsed)
+      sectionBucket = parsed.sectionBucket;
+    if ("sectionPrefix" in parsed)
+      sectionPrefix = parsed.sectionPrefix;
+  }
+  return { directives, sectionBucket, sectionPrefix };
+}
+function parseDirectiveToken(token, lineNumber) {
+  if (!token.startsWith("@")) {
+    throw new Error(`Malformed directive at line ${lineNumber}: "${token}"`);
+  }
+  const spaceIndex = token.indexOf(" ");
+  const name = (spaceIndex === -1 ? token.slice(1) : token.slice(1, spaceIndex)).trim();
+  const value = (spaceIndex === -1 ? "" : token.slice(spaceIndex + 1)).trim();
+  if (name === "server" || name === "client" || name === "shared") {
+    return value.length > 0 ? { sectionBucket: name, sectionPrefix: value } : { sectionBucket: name };
+  }
+  if (name === "type") {
+    if (value.length === 0) {
+      throw new Error(`Directive "@type" requires a value at line ${lineNumber}`);
+    }
+    if (value === "enum" || value.startsWith("enum ")) {
+      const raw = value.slice(4).trim();
+      if (raw.length === 0) {
+        throw new Error(`Directive "@type enum" requires comma-separated values at line ${lineNumber}`);
+      }
+      const stringEnumValues = raw.split(",").map((v) => v.trim()).filter(Boolean);
+      if (stringEnumValues.length === 0) {
+        throw new Error(`Directive "@type enum" requires at least one value at line ${lineNumber}`);
+      }
+      return { type: "stringEnum", stringEnumValues };
+    }
+    return { type: parseSchemaKind(value, lineNumber) };
+  }
+  if (name === "optional") {
+    return { optional: parseBooleanDirective(value || undefined, true) };
+  }
+  if (name === "no-default") {
+    return { hasDefault: false };
+  }
+  if (name === "redacted") {
+    return { redacted: parseBooleanDirective(value || undefined, true) };
+  }
+  if (name === "bucket") {
+    if (value.length === 0) {
+      throw new Error(`Directive "@bucket" requires a value at line ${lineNumber}`);
+    }
+    if (!isBucket(value)) {
+      throw new Error(`Invalid bucket "${value}" at line ${lineNumber}`);
+    }
+    return { bucket: value };
+  }
+  throw new Error(`Unknown directive "@${name}" at line ${lineNumber}`);
+}
+function parseSchemaKind(rawValue, lineNumber) {
+  const normalized = rawValue.trim().toLowerCase();
+  const aliasMap = {
+    string: "requiredString",
+    requiredstring: "requiredString",
+    bool: "boolean",
+    boolean: "boolean",
+    int: "integer",
+    integer: "integer",
+    number: "number",
+    port: "port",
+    url: "url",
+    postgresurl: "postgresUrl",
+    redisurl: "redisUrl",
+    mongourl: "mongoUrl",
+    mysqlurl: "mysqlUrl",
+    commaseparated: "commaSeparated",
+    commaseparatednumbers: "commaSeparatedNumbers",
+    commaseparatedurls: "commaSeparatedUrls",
+    json: "json",
+    "json(schema.unknown)": "json"
+  };
+  const resolved = aliasMap[normalized];
+  if (!resolved || !SCHEMA_KINDS.includes(resolved)) {
+    throw new Error(`Invalid @type value "${rawValue}" at line ${lineNumber}`);
+  }
+  return resolved;
+}
+function normalizeAssignedValue(value) {
+  if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+    return value.slice(1, -1);
+  }
+  return value;
+}
+function serializeEnvValue(value) {
+  const literal = toEnvValueLiteral(value);
+  if (literal.length === 0)
+    return "";
+  if (/[\s#]/.test(literal)) {
+    return JSON.stringify(literal);
+  }
+  return literal;
+}
+function isBucket(value) {
+  return BUCKETS.includes(value);
+}
+
+// src/schemas.ts
+import { Function, Schema as Schema3 } from "effect";
+var DEFAULT_VALUE_ANNOTATION = Symbol.for("@ayronforge/envil/default-value");
+var SCHEMA_KIND_ANNOTATION = Symbol.for("@ayronforge/envil/schema-kind");
+var PLACEHOLDER_ANNOTATION = Symbol.for("@ayronforge/envil/placeholder");
+var OPTIONAL_ANNOTATION = Symbol.for("@ayronforge/envil/optional");
+var REDACTED_ANNOTATION = Symbol.for("@ayronforge/envil/redacted");
+var STRING_ENUM_VALUES_ANNOTATION = Symbol.for("@ayronforge/envil/string-enum-values");
+var withDefault = Function.dual(2, (schema, defaultValue) => {
+  const withDefaultSchema = Schema3.transform(Schema3.UndefinedOr(schema), Schema3.typeSchema(schema), {
+    decode: (value) => value ?? defaultValue,
+    encode: (value) => value
+  });
+  return withDefaultSchema.annotations({
+    [DEFAULT_VALUE_ANNOTATION]: defaultValue
+  });
+});
+var optional = (schema) => Schema3.UndefinedOr(schema).annotations({
+  [OPTIONAL_ANNOTATION]: true
+});
+var redacted = (schema) => Schema3.Redacted(schema).annotations({
+  [REDACTED_ANNOTATION]: true
+});
+var requiredString = Schema3.String.pipe(Schema3.minLength(1)).annotations({
+  identifier: "RequiredString",
+  [SCHEMA_KIND_ANNOTATION]: "requiredString",
+  [PLACEHOLDER_ANNOTATION]: "CHANGE_ME"
+});
+var boolean = Schema3.transform(Schema3.String.pipe(Schema3.filter((s) => ["true", "false", "1", "0"].includes(s.toLowerCase()), {
+  identifier: "BooleanString",
+  message: () => "Expected 'true', 'false', '1', or '0'"
+})), Schema3.Boolean, {
+  decode: (s) => s.toLowerCase() === "true" || s === "1",
+  encode: (b) => b ? "true" : "false"
+}).annotations({
+  [SCHEMA_KIND_ANNOTATION]: "boolean",
+  [PLACEHOLDER_ANNOTATION]: "true"
+});
+var integer = Schema3.NumberFromString.pipe(Schema3.int()).annotations({
+  identifier: "Integer",
+  [SCHEMA_KIND_ANNOTATION]: "integer",
+  [PLACEHOLDER_ANNOTATION]: "123"
+});
+var number = Schema3.NumberFromString.annotations({
+  identifier: "Number",
+  [SCHEMA_KIND_ANNOTATION]: "number",
+  [PLACEHOLDER_ANNOTATION]: "3.14"
+});
+var positiveNumber = Schema3.NumberFromString.pipe(Schema3.positive()).annotations({
+  identifier: "PositiveNumber"
+});
+var nonNegativeNumber = Schema3.NumberFromString.pipe(Schema3.nonNegative()).annotations({
+  identifier: "NonNegativeNumber"
+});
+var port = Schema3.NumberFromString.pipe(Schema3.int(), Schema3.between(1, 65535)).annotations({
+  identifier: "Port",
+  [SCHEMA_KIND_ANNOTATION]: "port",
+  [PLACEHOLDER_ANNOTATION]: "3000"
+});
+var url = Schema3.String.pipe(Schema3.filter((s) => {
+  try {
+    new URL(s);
+    return s.startsWith("http://") || s.startsWith("https://");
+  } catch {
+    return false;
+  }
+}, { identifier: "Url", message: () => "Expected a valid HTTP or HTTPS URL" })).annotations({
+  [SCHEMA_KIND_ANNOTATION]: "url",
+  [PLACEHOLDER_ANNOTATION]: "https://example.com"
+});
+var postgresUrl = Schema3.String.pipe(Schema3.filter((s) => s.startsWith("postgres://") || s.startsWith("postgresql://"), {
+  identifier: "PostgresUrl",
+  message: () => "Expected a valid PostgreSQL connection URL"
+}), Schema3.pattern(/^(postgres|postgresql):\/\/[^:]+:[^@]+@[^:]+:\d+\/.+$/)).annotations({
+  [SCHEMA_KIND_ANNOTATION]: "postgresUrl",
+  [PLACEHOLDER_ANNOTATION]: "postgres://user:pass@localhost:5432/app"
+});
+var redisUrl = Schema3.String.pipe(Schema3.filter((s) => s.startsWith("redis://") || s.startsWith("rediss://"), {
+  identifier: "RedisUrl",
+  message: () => "Expected a valid Redis connection URL"
+}), Schema3.pattern(/^rediss?:\/\/(?:[^:]+:[^@]+@)?[^:]+(?::\d+)?(?:\/\d+)?$/)).annotations({
+  [SCHEMA_KIND_ANNOTATION]: "redisUrl",
+  [PLACEHOLDER_ANNOTATION]: "redis://localhost:6379"
+});
+var mongoUrl = Schema3.String.pipe(Schema3.filter((s) => s.startsWith("mongodb://") || s.startsWith("mongodb+srv://"), {
+  identifier: "MongoUrl",
+  message: () => "Expected a valid MongoDB connection URL"
+}), Schema3.pattern(/^mongodb(\+srv)?:\/\/(?:[^:]+:[^@]+@)?[^/]+(?:\/[^?]*)?(?:\?.*)?$/)).annotations({
+  [SCHEMA_KIND_ANNOTATION]: "mongoUrl",
+  [PLACEHOLDER_ANNOTATION]: "mongodb://localhost:27017/app"
+});
+var mysqlUrl = Schema3.String.pipe(Schema3.filter((s) => s.startsWith("mysql://") || s.startsWith("mysqls://"), {
+  identifier: "MysqlUrl",
+  message: () => "Expected a valid MySQL connection URL"
+}), Schema3.pattern(/^mysqls?:\/\/[^:]+:[^@]+@[^:]+:\d+\/.+$/)).annotations({
+  [SCHEMA_KIND_ANNOTATION]: "mysqlUrl",
+  [PLACEHOLDER_ANNOTATION]: "mysql://user:pass@localhost:3306/app"
+});
+var commaSeparated = Schema3.transform(Schema3.String, Schema3.mutable(Schema3.Array(Schema3.String)), {
+  decode: (s) => s.split(",").map((x) => x.trim()),
+  encode: (a) => a.join(",")
+}).annotations({
+  [SCHEMA_KIND_ANNOTATION]: "commaSeparated",
+  [PLACEHOLDER_ANNOTATION]: "alpha,beta,gamma"
+});
+var commaSeparatedNumbers = Schema3.transform(Schema3.String, Schema3.mutable(Schema3.Array(Schema3.Number)), {
+  decode: (s) => s.split(",").map((x) => {
+    const n = Number(x.trim());
+    if (Number.isNaN(n))
+      throw new Error(`"${x.trim()}" is not a valid number`);
+    return n;
+  }),
+  encode: (a) => a.join(",")
+}).annotations({
+  [SCHEMA_KIND_ANNOTATION]: "commaSeparatedNumbers",
+  [PLACEHOLDER_ANNOTATION]: "1,2,3"
+});
+var commaSeparatedUrls = Schema3.transform(Schema3.String, Schema3.mutable(Schema3.Array(url)), {
+  decode: (s) => s.split(",").map((x) => Schema3.decodeUnknownSync(url)(x.trim())),
+  encode: (a) => a.join(",")
+}).annotations({
+  [SCHEMA_KIND_ANNOTATION]: "commaSeparatedUrls",
+  [PLACEHOLDER_ANNOTATION]: "https://one.example.com,https://two.example.com"
+});
+var stringEnum = (values) => Schema3.Literal(...values).annotations({
+  [SCHEMA_KIND_ANNOTATION]: "stringEnum",
+  [STRING_ENUM_VALUES_ANNOTATION]: values,
+  [PLACEHOLDER_ANNOTATION]: values[0]
+});
+var json = (schema) => Schema3.parseJson(schema).annotations({
+  [SCHEMA_KIND_ANNOTATION]: "json",
+  [PLACEHOLDER_ANNOTATION]: '{"key":"value"}'
+});
+
+// src/introspect.ts
+var BUCKETS2 = ["server", "client", "shared"];
+function getAnn(ast, key) {
+  return Option.getOrUndefined(SchemaAST.getAnnotation(ast, key));
+}
+function examineSchema(schema) {
+  let ast = schema.ast;
+  let isRedacted = false;
+  let isOptional = false;
+  let hasDefault = false;
+  let defaultValue = undefined;
+  if (SchemaAST.isTransformation(ast) && getAnn(ast, REDACTED_ANNOTATION)) {
+    isRedacted = true;
+    ast = ast.from;
+  }
+  if (SchemaAST.isTransformation(ast) && getAnn(ast, DEFAULT_VALUE_ANNOTATION) !== undefined) {
+    hasDefault = true;
+    defaultValue = getAnn(ast, DEFAULT_VALUE_ANNOTATION);
+    const fromAst = ast.from;
+    if (SchemaAST.isUnion(fromAst)) {
+      const nonUndefined = fromAst.types.find((t) => !SchemaAST.isUndefinedKeyword(t));
+      if (nonUndefined)
+        ast = nonUndefined;
+    }
+  }
+  if (SchemaAST.isUnion(ast) && getAnn(ast, OPTIONAL_ANNOTATION)) {
+    isOptional = true;
+    const nonUndefined = ast.types.find((t) => !SchemaAST.isUndefinedKeyword(t));
+    if (nonUndefined)
+      ast = nonUndefined;
+  }
+  const kind = getAnn(ast, SCHEMA_KIND_ANNOTATION);
+  const placeholder = getAnn(ast, PLACEHOLDER_ANNOTATION);
+  const stringEnumValues = kind === "stringEnum" ? getAnn(ast, STRING_ENUM_VALUES_ANNOTATION) : undefined;
+  return {
+    kind,
+    placeholder,
+    optional: isOptional,
+    hasDefault,
+    defaultValue,
+    redacted: isRedacted,
+    stringEnumValues
+  };
+}
+function buildEnvExample(definition) {
+  const prefix = {
+    server: definition.prefix?.server ?? "",
+    client: definition.prefix?.client ?? "",
+    shared: definition.prefix?.shared ?? ""
+  };
+  const entries = [];
+  let line = 1;
+  for (const bucket of BUCKETS2) {
+    const schemas = definition[bucket] ?? {};
+    const keys = Object.keys(schemas).sort();
+    for (const key of keys) {
+      const schema = schemas[key];
+      const examined = examineSchema(schema);
+      const runtimeKey = `${prefix[bucket]}${key}`;
+      let value;
+      if (examined.hasDefault) {
+        value = encodeDefault(schema, examined);
+      } else {
+        value = examined.placeholder ?? "CHANGE_ME";
+      }
+      entries.push({
+        key: runtimeKey,
+        value,
+        line,
+        sectionBucket: bucket,
+        directives: {
+          type: examined.kind,
+          bucket,
+          optional: examined.optional,
+          hasDefault: examined.hasDefault,
+          redacted: examined.redacted,
+          stringEnumValues: examined.stringEnumValues
+        }
+      });
+      line += 1;
+    }
+  }
+  const hasPrefix = Object.values(prefix).some((v) => v.length > 0);
+  return encodeDotenvText({ entries, ...hasPrefix ? { prefix } : {} });
+}
+function encodeDefault(schema, examined) {
+  try {
+    let valueToEncode = examined.defaultValue;
+    if (examined.redacted) {
+      valueToEncode = Redacted2.make(valueToEncode);
+    }
+    const encoded = Schema4.encodeSync(schema)(valueToEncode);
+    return String(encoded ?? "");
+  } catch {
+    return stringifyDefault(examined);
+  }
+}
+function stringifyDefault(examined) {
+  const val = examined.defaultValue;
+  if (val === undefined || val === null)
+    return "";
+  if (Array.isArray(val))
+    return val.map(String).join(",");
+  if (typeof val === "object")
+    return JSON.stringify(val);
+  return String(val);
+}
 // src/resolvers/remote.ts
 import { Effect as Effect3 } from "effect";
 
@@ -332,84 +908,6 @@ function safeCreateEnv(opts) {
     return { success: false, error: normalizeEnvValidationError(error) };
   }
 }
-// src/schemas.ts
-import { Function, Schema as Schema2 } from "effect";
-var DEFAULT_VALUE_ANNOTATION = Symbol.for("@ayronforge/envil/default-value");
-var withDefault = Function.dual(2, (schema, defaultValue) => {
-  const withDefaultSchema = Schema2.transform(Schema2.UndefinedOr(schema), Schema2.typeSchema(schema), {
-    decode: (value) => value ?? defaultValue,
-    encode: (value) => value
-  });
-  return withDefaultSchema.annotations({
-    [DEFAULT_VALUE_ANNOTATION]: defaultValue
-  });
-});
-var optional = (schema) => Schema2.UndefinedOr(schema);
-var redacted = (schema) => Schema2.Redacted(schema);
-var requiredString = Schema2.String.pipe(Schema2.minLength(1)).annotations({
-  identifier: "RequiredString"
-});
-var optionalString = Schema2.UndefinedOr(Schema2.String);
-var positiveNumber = Schema2.NumberFromString.pipe(Schema2.positive()).annotations({
-  identifier: "PositiveNumber"
-});
-var commaSeparated = Schema2.transform(Schema2.String, Schema2.mutable(Schema2.Array(Schema2.String)), {
-  decode: (s) => s.split(",").map((x) => x.trim()),
-  encode: (a) => a.join(",")
-});
-var commaSeparatedNumbers = Schema2.transform(Schema2.String, Schema2.mutable(Schema2.Array(Schema2.Number)), {
-  decode: (s) => s.split(",").map((x) => {
-    const n = Number(x.trim());
-    if (Number.isNaN(n))
-      throw new Error(`"${x.trim()}" is not a valid number`);
-    return n;
-  }),
-  encode: (a) => a.join(",")
-});
-var url = Schema2.String.pipe(Schema2.filter((s) => {
-  try {
-    new URL(s);
-    return s.startsWith("http://") || s.startsWith("https://");
-  } catch {
-    return false;
-  }
-}, { identifier: "Url", message: () => "Expected a valid HTTP or HTTPS URL" }));
-var postgresUrl = Schema2.String.pipe(Schema2.filter((s) => s.startsWith("postgres://") || s.startsWith("postgresql://"), {
-  identifier: "PostgresUrl",
-  message: () => "Expected a valid PostgreSQL connection URL"
-}), Schema2.pattern(/^(postgres|postgresql):\/\/[^:]+:[^@]+@[^:]+:\d+\/.+$/));
-var redisUrl = Schema2.String.pipe(Schema2.filter((s) => s.startsWith("redis://") || s.startsWith("rediss://"), {
-  identifier: "RedisUrl",
-  message: () => "Expected a valid Redis connection URL"
-}), Schema2.pattern(/^rediss?:\/\/(?:[^:]+:[^@]+@)?[^:]+(?::\d+)?(?:\/\d+)?$/));
-var commaSeparatedUrls = Schema2.transform(Schema2.String, Schema2.mutable(Schema2.Array(url)), {
-  decode: (s) => s.split(",").map((x) => Schema2.decodeUnknownSync(url)(x.trim())),
-  encode: (a) => a.join(",")
-});
-var boolean = Schema2.transform(Schema2.String.pipe(Schema2.filter((s) => ["true", "false", "1", "0"].includes(s.toLowerCase()), {
-  identifier: "BooleanString",
-  message: () => "Expected 'true', 'false', '1', or '0'"
-})), Schema2.Boolean, {
-  decode: (s) => s.toLowerCase() === "true" || s === "1",
-  encode: (b) => b ? "true" : "false"
-});
-var integer = Schema2.NumberFromString.pipe(Schema2.int()).annotations({
-  identifier: "Integer"
-});
-var nonNegativeNumber = Schema2.NumberFromString.pipe(Schema2.nonNegative()).annotations({
-  identifier: "NonNegativeNumber"
-});
-var port = Schema2.NumberFromString.pipe(Schema2.int(), Schema2.between(1, 65535)).annotations({ identifier: "Port" });
-var stringEnum = (values) => Schema2.Literal(...values);
-var json = (schema) => Schema2.parseJson(schema);
-var mongoUrl = Schema2.String.pipe(Schema2.filter((s) => s.startsWith("mongodb://") || s.startsWith("mongodb+srv://"), {
-  identifier: "MongoUrl",
-  message: () => "Expected a valid MongoDB connection URL"
-}), Schema2.pattern(/^mongodb(\+srv)?:\/\/(?:[^:]+:[^@]+@)?[^/]+(?:\/[^?]*)?(?:\?.*)?$/));
-var mysqlUrl = Schema2.String.pipe(Schema2.filter((s) => s.startsWith("mysql://") || s.startsWith("mysqls://"), {
-  identifier: "MysqlUrl",
-  message: () => "Expected a valid MySQL connection URL"
-}), Schema2.pattern(/^mysqls?:\/\/[^:]+:[^@]+@[^:]+:\d+\/.+$/));
 export {
   withDefault,
   url,
@@ -421,23 +919,30 @@ export {
   postgresUrl,
   positiveNumber,
   port,
-  optionalString,
   optional,
+  number,
   nonNegativeNumber,
   mysqlUrl,
   mongoUrl,
   json,
   integer,
   fromRemoteSecrets,
+  examineSchema,
   createEnv,
   commaSeparatedUrls,
   commaSeparatedNumbers,
   commaSeparated,
+  buildEnvExample,
   boolean,
+  STRING_ENUM_VALUES_ANNOTATION,
+  SCHEMA_KIND_ANNOTATION,
+  REDACTED_ANNOTATION,
+  PLACEHOLDER_ANNOTATION,
+  OPTIONAL_ANNOTATION,
   EnvValidationError,
   DEFAULT_VALUE_ANNOTATION,
   ClientAccessError
 };
 
-//# debugId=83E78DCC4BD19C8E64756E2164756E21
+//# debugId=D41C1808EDE7815C64756E2164756E21
 //# sourceMappingURL=index.js.map