@ayronforge/envil 0.6.0 → 0.7.2

package/dist/cli.js

@@ -65,39 +65,6 @@ async function writeFileAtomic(targetPath, contents) {
 import { Schema } from "effect";
 
 // src/cli/literals.ts
-function parseLiteral(input) {
-  const trimmed = input.trim();
-  if (trimmed.length === 0) {
-    return "";
-  }
-  if (trimmed.startsWith('"') && trimmed.endsWith('"') || trimmed.startsWith("'") && trimmed.endsWith("'")) {
-    try {
-      return JSON.parse(trimmed.replace(/^'/, '"').replace(/'$/, '"'));
-    } catch {
-      return trimmed.slice(1, -1);
-    }
-  }
-  if (trimmed === "true")
-    return true;
-  if (trimmed === "false")
-    return false;
-  if (trimmed === "null")
-    return null;
-  if (/^[+-]?\d+(?:\.\d+)?$/.test(trimmed)) {
-    const value = Number(trimmed);
-    if (!Number.isNaN(value)) {
-      return value;
-    }
-  }
-  if (trimmed.startsWith("{") && trimmed.endsWith("}") || trimmed.startsWith("[") && trimmed.endsWith("]")) {
-    try {
-      return JSON.parse(trimmed);
-    } catch {
-      return trimmed;
-    }
-  }
-  return trimmed;
-}
 function toCodeLiteral(value) {
   if (typeof value === "string")
     return JSON.stringify(value);
@@ -109,11 +76,6 @@ function toCodeLiteral(value) {
     return "undefined";
   return JSON.stringify(value);
 }
-function toDirectiveLiteral(value) {
-  if (value === undefined)
-    return "";
-  return toCodeLiteral(value);
-}
 function toEnvValueLiteral(value) {
   if (typeof value === "string")
     return value;
@@ -151,10 +113,10 @@ var SCHEMA_KINDS = [
   "commaSeparated",
   "commaSeparatedNumbers",
   "commaSeparatedUrls",
-  "json"
+  "json",
+  "stringEnum"
 ];
 var FRAMEWORKS = ["nextjs", "vite", "expo", "nuxt", "sveltekit", "astro"];
-var MANIFEST_VERSION = 1;
 
 // src/cli/dotenv-codec.ts
 var SENTINEL_DIRECTIVE_PREFIX = "@";
@@ -172,6 +134,7 @@ function encodeDotenvText(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()) {
@@ -186,6 +149,9 @@ function parseDotenvText(text) {
         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;
@@ -221,7 +187,8 @@ function parseDotenvText(text) {
     });
     pendingDirectives = {};
   }
-  return { entries };
+  const hasPrefix = Object.values(prefix).some((v) => v && v.length > 0);
+  return { entries, ...hasPrefix ? { prefix } : {} };
 }
 function stringifyDotenvDocument(document) {
   if (!document || !Array.isArray(document.entries)) {
@@ -243,19 +210,22 @@ function stringifyDotenvDocument(document) {
   }
   const lines = [];
   for (const bucket of BUCKETS) {
-    lines.push(`# @${bucket}`);
+    const pfx = document.prefix?.[bucket];
+    lines.push(pfx && pfx.length > 0 ? `# @${bucket} ${pfx}` : `# @${bucket}`);
     lines.push("");
     for (const entry of grouped[bucket]) {
-      const type = entry.directives.type ?? "requiredString";
       const optional = entry.directives.optional ?? false;
-      const hasDefault = entry.directives.hasDefault ?? false;
       const redacted = entry.directives.redacted ?? false;
-      const defaultLiteral = hasDefault ? ` ${toDirectiveLiteral(entry.directives.defaultValue)}` : "";
-      lines.push(`# @type ${type}`);
-      lines.push(`# @bucket ${bucket}`);
-      lines.push(`# @optional ${optional}`);
-      lines.push(`# @default${defaultLiteral}`);
-      lines.push(`# @redacted ${redacted}`);
+      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("");
     }
@@ -302,6 +272,7 @@ 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)
@@ -310,16 +281,18 @@ function parseDirectiveGroup(directiveText, lineNumber, base) {
       directives.optional = parsed.optional;
     if ("hasDefault" in parsed)
       directives.hasDefault = parsed.hasDefault;
-    if ("defaultValue" in parsed)
-      directives.defaultValue = parsed.defaultValue;
     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 };
+  return { directives, sectionBucket, sectionPrefix };
 }
 function parseDirectiveToken(token, lineNumber) {
   if (!token.startsWith("@")) {
@@ -329,25 +302,30 @@ function parseDirectiveToken(token, lineNumber) {
   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") {
-    if (value.length > 0) {
-      throw new Error(`Section directive "@${name}" must not include a value (line ${lineNumber})`);
-    }
-    return { sectionBucket: name };
+    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 === "default") {
-    if (value.length === 0) {
-      return { hasDefault: false, defaultValue: undefined };
-    }
-    return { hasDefault: true, defaultValue: parseLiteral(value) };
+  if (name === "no-default") {
+    return { hasDefault: false };
   }
   if (name === "redacted") {
     return { redacted: parseBooleanDirective(value || undefined, true) };
@@ -409,183 +387,6 @@ function serializeEnvValue(value) {
 function isBucket(value) {
   return BUCKETS.includes(value);
 }
-// src/cli/generate-example.ts
-var PLACEHOLDERS = {
-  requiredString: "CHANGE_ME",
-  boolean: "true",
-  integer: "123",
-  number: "3.14",
-  port: "3000",
-  url: "https://example.com",
-  postgresUrl: "postgres://user:pass@localhost:5432/app",
-  redisUrl: "redis://localhost:6379",
-  mongoUrl: "mongodb://localhost:27017/app",
-  mysqlUrl: "mysql://user:pass@localhost:3306/app",
-  commaSeparated: "alpha,beta,gamma",
-  commaSeparatedNumbers: "1,2,3",
-  commaSeparatedUrls: "https://one.example.com,https://two.example.com",
-  json: '{"key":"value"}'
-};
-function generateExample(manifest) {
-  const entries = [];
-  let line = 1;
-  for (const bucket of BUCKETS) {
-    const variables = manifest.variables.filter((variable) => variable.bucket === bucket).sort((left, right) => left.name.localeCompare(right.name));
-    for (const variable of variables) {
-      const runtimeKey = `${manifest.prefix[bucket]}${variable.name}`;
-      const value = variable.hasDefault ? renderDefaultValue(variable) : PLACEHOLDERS[variable.kind] ?? PLACEHOLDERS.requiredString;
-      entries.push({
-        key: runtimeKey,
-        value,
-        line,
-        sectionBucket: bucket,
-        directives: {
-          type: variable.kind,
-          bucket,
-          optional: variable.optional,
-          hasDefault: variable.hasDefault,
-          defaultValue: variable.defaultValue,
-          redacted: variable.redacted
-        }
-      });
-      line += 1;
-    }
-  }
-  return encodeDotenvText({ entries });
-}
-function renderDefaultValue(variable) {
-  if (!variable.hasDefault) {
-    return PLACEHOLDERS[variable.kind];
-  }
-  if (variable.kind === "commaSeparated") {
-    if (Array.isArray(variable.defaultValue)) {
-      return variable.defaultValue.map((item) => String(item)).join(",");
-    }
-    return String(variable.defaultValue ?? "");
-  }
-  if (variable.kind === "commaSeparatedNumbers") {
-    if (Array.isArray(variable.defaultValue)) {
-      return variable.defaultValue.map((item) => Number(item)).filter((item) => Number.isFinite(item)).join(",");
-    }
-    return String(variable.defaultValue ?? "0");
-  }
-  if (variable.kind === "commaSeparatedUrls") {
-    if (Array.isArray(variable.defaultValue)) {
-      return variable.defaultValue.map((item) => String(item)).join(",");
-    }
-    return String(variable.defaultValue ?? PLACEHOLDERS.commaSeparatedUrls);
-  }
-  if (variable.kind === "json") {
-    if (typeof variable.defaultValue === "string") {
-      return variable.defaultValue;
-    }
-    return JSON.stringify(variable.defaultValue ?? {});
-  }
-  return toEnvValueLiteral(variable.defaultValue);
-}
-// src/cli/manifest-codec.ts
-import { Schema as Schema2 } from "effect";
-var MANIFEST_SENTINEL = "@envil:manifest";
-var MANIFEST_BLOCK_PATTERN = /\/\*\s*@envil:manifest\s*([\s\S]*?)\*\//m;
-var ManifestCodec = Schema2.transform(Schema2.String, Schema2.Unknown, {
-  decode: (source) => decodeManifestFromSourceText(String(source)),
-  encode: (value) => encodeManifestToBlockComment(value)
-});
-function decodeManifestFromSource(source) {
-  return Schema2.decodeUnknownSync(ManifestCodec)(source);
-}
-function encodeManifestBlock(manifest) {
-  return Schema2.encodeSync(ManifestCodec)(manifest);
-}
-function decodeManifestFromSourceText(source) {
-  const match = MANIFEST_BLOCK_PATTERN.exec(source);
-  if (!match) {
-    throw new Error("Manifest block not found. Expected a top-level @envil:manifest block comment.");
-  }
-  const jsonText = match[1].trim();
-  let parsed;
-  try {
-    parsed = JSON.parse(jsonText);
-  } catch (error) {
-    throw new Error(`Malformed manifest JSON: ${String(error)}`);
-  }
-  return validateManifest(parsed);
-}
-function encodeManifestToBlockComment(manifest) {
-  const normalized = validateManifest(manifest);
-  return `/* ${MANIFEST_SENTINEL}
-${JSON.stringify(normalized, null, 2)}
-*/`;
-}
-function validateManifest(value) {
-  if (!value || typeof value !== "object") {
-    throw new Error("Manifest must be an object.");
-  }
-  const candidate = value;
-  if (candidate.version !== MANIFEST_VERSION) {
-    throw new Error(`Unsupported manifest version "${String(candidate.version)}".`);
-  }
-  const prefix = validatePrefix(candidate.prefix);
-  const variablesRaw = candidate.variables;
-  if (!Array.isArray(variablesRaw)) {
-    throw new Error('Manifest field "variables" must be an array.');
-  }
-  const variables = variablesRaw.map((item, index) => validateManifestVariable(item, index));
-  variables.sort((left, right) => {
-    if (left.bucket !== right.bucket)
-      return left.bucket.localeCompare(right.bucket);
-    return left.name.localeCompare(right.name);
-  });
-  return {
-    version: MANIFEST_VERSION,
-    prefix,
-    variables
-  };
-}
-function validatePrefix(prefixValue) {
-  if (!prefixValue || typeof prefixValue !== "object") {
-    throw new Error('Manifest field "prefix" must be an object.');
-  }
-  const prefix = prefixValue;
-  const server = typeof prefix.server === "string" ? prefix.server : "";
-  const client = typeof prefix.client === "string" ? prefix.client : "";
-  const shared = typeof prefix.shared === "string" ? prefix.shared : "";
-  return { server, client, shared };
-}
-function validateManifestVariable(value, index) {
-  if (!value || typeof value !== "object") {
-    throw new Error(`Manifest variable at index ${index} must be an object.`);
-  }
-  const variable = value;
-  if (typeof variable.name !== "string" || variable.name.length === 0) {
-    throw new Error(`Manifest variable at index ${index} has an invalid "name".`);
-  }
-  if (typeof variable.bucket !== "string" || !BUCKETS.includes(variable.bucket)) {
-    throw new Error(`Manifest variable "${variable.name}" has an invalid "bucket".`);
-  }
-  if (typeof variable.kind !== "string" || !SCHEMA_KINDS.includes(variable.kind)) {
-    throw new Error(`Manifest variable "${variable.name}" has an invalid "kind".`);
-  }
-  if (typeof variable.optional !== "boolean") {
-    throw new Error(`Manifest variable "${variable.name}" has an invalid "optional" flag.`);
-  }
-  if (typeof variable.hasDefault !== "boolean") {
-    throw new Error(`Manifest variable "${variable.name}" has an invalid "hasDefault" flag.`);
-  }
-  if (typeof variable.redacted !== "boolean") {
-    throw new Error(`Manifest variable "${variable.name}" has an invalid "redacted" flag.`);
-  }
-  return {
-    name: variable.name,
-    bucket: variable.bucket,
-    kind: variable.kind,
-    optional: variable.optional,
-    hasDefault: variable.hasDefault,
-    defaultValue: variable.defaultValue,
-    redacted: variable.redacted
-  };
-}
-
 // src/cli/generate-env-ts.ts
 function generateEnvTs(model) {
   const sortedVariables = [...model.variables].sort((left, right) => {
@@ -605,7 +406,8 @@ function generateEnvTs(model) {
       optional: variable.optional,
       hasDefault: variable.hasDefault,
       defaultValue: variable.defaultValue,
-      redacted: variable.redacted
+      redacted: variable.redacted,
+      stringEnumValues: variable.stringEnumValues
     });
     for (const helper of rendered.helpers) {
       helperImports.add(helper);
@@ -618,10 +420,7 @@ function generateEnvTs(model) {
   }
   const importLine = `import { ${[...helperImports].sort().join(", ")} } from "@ayronforge/envil";`;
   const schemaImportLine = needsSchemaImport ? `import { Schema } from "effect";` : "";
-  const manifestBlock = encodeManifestBlock(toManifest(model));
   const sourceLines = [
-    manifestBlock,
-    "",
     importLine,
     schemaImportLine,
     "",
@@ -655,9 +454,9 @@ function renderBucketEntries(entries) {
   return entries.map((entry) => `    ${entry.key}: ${entry.expression},`);
 }
 function renderSchemaExpression(kind, wrappers) {
-  let expression = renderBaseExpression(kind);
-  const helpers = new Set(requiredHelpersForKind(kind));
-  const needsSchemaImport = kind === "number" || kind === "json";
+  let expression = kind === "stringEnum" && wrappers.stringEnumValues ? `stringEnum([${wrappers.stringEnumValues.map((v) => JSON.stringify(v)).join(", ")}])` : SPECIAL_EXPRESSIONS[kind] ?? kind;
+  const helpers = new Set([kind]);
+  const needsSchemaImport = kind === "json";
   if (wrappers.optional && !wrappers.hasDefault) {
     expression = `optional(${expression})`;
     helpers.add("optional");
@@ -672,97 +471,13 @@ function renderSchemaExpression(kind, wrappers) {
   }
   return { expression, helpers, needsSchemaImport };
 }
-function renderBaseExpression(kind) {
-  switch (kind) {
-    case "requiredString":
-      return "requiredString";
-    case "boolean":
-      return "boolean";
-    case "integer":
-      return "integer";
-    case "number":
-      return "Schema.NumberFromString";
-    case "port":
-      return "port";
-    case "url":
-      return "url";
-    case "postgresUrl":
-      return "postgresUrl";
-    case "redisUrl":
-      return "redisUrl";
-    case "mongoUrl":
-      return "mongoUrl";
-    case "mysqlUrl":
-      return "mysqlUrl";
-    case "commaSeparated":
-      return "commaSeparated";
-    case "commaSeparatedNumbers":
-      return "commaSeparatedNumbers";
-    case "commaSeparatedUrls":
-      return "commaSeparatedUrls";
-    case "json":
-      return "json(Schema.Unknown)";
-    default:
-      return "requiredString";
-  }
-}
-function requiredHelpersForKind(kind) {
-  switch (kind) {
-    case "requiredString":
-      return ["requiredString"];
-    case "boolean":
-      return ["boolean"];
-    case "integer":
-      return ["integer"];
-    case "number":
-      return [];
-    case "port":
-      return ["port"];
-    case "url":
-      return ["url"];
-    case "postgresUrl":
-      return ["postgresUrl"];
-    case "redisUrl":
-      return ["redisUrl"];
-    case "mongoUrl":
-      return ["mongoUrl"];
-    case "mysqlUrl":
-      return ["mysqlUrl"];
-    case "commaSeparated":
-      return ["commaSeparated"];
-    case "commaSeparatedNumbers":
-      return ["commaSeparatedNumbers"];
-    case "commaSeparatedUrls":
-      return ["commaSeparatedUrls"];
-    case "json":
-      return ["json"];
-    default:
-      return ["requiredString"];
-  }
-}
+var SPECIAL_EXPRESSIONS = {
+  json: "json(Schema.Unknown)",
+  stringEnum: "stringEnum([])"
+};
 function quoteObjectKey(value) {
   return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(value) ? value : JSON.stringify(value);
 }
-function toManifest(model) {
-  const variables = [...model.variables].map((variable) => ({
-    name: variable.schemaKey,
-    bucket: variable.bucket,
-    kind: variable.kind,
-    optional: variable.optional,
-    hasDefault: variable.hasDefault,
-    defaultValue: variable.defaultValue,
-    redacted: variable.redacted
-  })).sort((left, right) => {
-    if (left.bucket !== right.bucket)
-      return left.bucket.localeCompare(right.bucket);
-    return left.name.localeCompare(right.name);
-  });
-  return {
-    version: MANIFEST_VERSION,
-    prefix: model.prefix,
-    variables
-  };
-}
 // src/cli/infer.ts
 var STRING_KINDS = new Set([
   "requiredString",
@@ -787,8 +502,9 @@ function inferModel(document, options) {
       sectionBucket: entry.sectionBucket
     });
     const resolvedKind = entry.directives.type ?? inferSchemaKind(entry.key, entry.value);
-    const hasDefault = entry.directives.hasDefault ?? false;
-    const defaultValue = hasDefault ? normalizeDefaultValue(resolvedKind, entry.directives.defaultValue) : undefined;
+    const hasValue = entry.value.trim().length > 0;
+    const hasDefault = entry.directives.hasDefault === false ? false : hasValue;
+    const defaultValue = hasDefault ? normalizeDefaultValue(resolvedKind, entry.value) : undefined;
     const optionalFlag = entry.directives.optional ?? false;
     const redactedFlag = entry.directives.redacted ?? false;
     const duplicate = inferredVariables.find((candidate) => candidate.bucket === bucket && candidate.schemaKey === schemaKey);
@@ -804,7 +520,8 @@ function inferModel(document, options) {
       hasDefault,
       defaultValue,
       redacted: redactedFlag,
-      sourceLine: entry.line
+      sourceLine: entry.line,
+      stringEnumValues: entry.directives.stringEnumValues
     });
   }
   inferredVariables.sort((left, right) => {
@@ -995,14 +712,269 @@ function normalizeDefaultValue(kind, value) {
     return [String(value ?? "https://example.com")];
   }
   if (kind === "json") {
+    if (typeof value === "string") {
+      try {
+        return JSON.parse(value);
+      } catch {
+        return {};
+      }
+    }
     return value ?? {};
   }
+  if (kind === "stringEnum") {
+    return String(value ?? "");
+  }
   if (STRING_KINDS.has(kind)) {
     const stringValue = String(value ?? "");
     return stringValue.length > 0 ? stringValue : "value";
   }
   return value;
 }
+// src/introspect.ts
+import { Option, Redacted, Schema as Schema3, SchemaAST } from "effect";
+
+// src/schemas.ts
+import { Function, Schema as Schema2 } 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 = 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).annotations({
+  [OPTIONAL_ANNOTATION]: true
+});
+var redacted = (schema) => Schema2.Redacted(schema).annotations({
+  [REDACTED_ANNOTATION]: true
+});
+var requiredString = Schema2.String.pipe(Schema2.minLength(1)).annotations({
+  identifier: "RequiredString",
+  [SCHEMA_KIND_ANNOTATION]: "requiredString",
+  [PLACEHOLDER_ANNOTATION]: "CHANGE_ME"
+});
+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"
+}).annotations({
+  [SCHEMA_KIND_ANNOTATION]: "boolean",
+  [PLACEHOLDER_ANNOTATION]: "true"
+});
+var integer = Schema2.NumberFromString.pipe(Schema2.int()).annotations({
+  identifier: "Integer",
+  [SCHEMA_KIND_ANNOTATION]: "integer",
+  [PLACEHOLDER_ANNOTATION]: "123"
+});
+var number = Schema2.NumberFromString.annotations({
+  identifier: "Number",
+  [SCHEMA_KIND_ANNOTATION]: "number",
+  [PLACEHOLDER_ANNOTATION]: "3.14"
+});
+var positiveNumber = Schema2.NumberFromString.pipe(Schema2.positive()).annotations({
+  identifier: "PositiveNumber"
+});
+var nonNegativeNumber = Schema2.NumberFromString.pipe(Schema2.nonNegative()).annotations({
+  identifier: "NonNegativeNumber"
+});
+var port = Schema2.NumberFromString.pipe(Schema2.int(), Schema2.between(1, 65535)).annotations({
+  identifier: "Port",
+  [SCHEMA_KIND_ANNOTATION]: "port",
+  [PLACEHOLDER_ANNOTATION]: "3000"
+});
+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" })).annotations({
+  [SCHEMA_KIND_ANNOTATION]: "url",
+  [PLACEHOLDER_ANNOTATION]: "https://example.com"
+});
+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+\/.+$/)).annotations({
+  [SCHEMA_KIND_ANNOTATION]: "postgresUrl",
+  [PLACEHOLDER_ANNOTATION]: "postgres://user:pass@localhost:5432/app"
+});
+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+)?$/)).annotations({
+  [SCHEMA_KIND_ANNOTATION]: "redisUrl",
+  [PLACEHOLDER_ANNOTATION]: "redis://localhost:6379"
+});
+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)?:\/\/(?:[^:]+:[^@]+@)?[^/]+(?:\/[^?]*)?(?:\?.*)?$/)).annotations({
+  [SCHEMA_KIND_ANNOTATION]: "mongoUrl",
+  [PLACEHOLDER_ANNOTATION]: "mongodb://localhost:27017/app"
+});
+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+\/.+$/)).annotations({
+  [SCHEMA_KIND_ANNOTATION]: "mysqlUrl",
+  [PLACEHOLDER_ANNOTATION]: "mysql://user:pass@localhost:3306/app"
+});
+var commaSeparated = Schema2.transform(Schema2.String, Schema2.mutable(Schema2.Array(Schema2.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 = 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(",")
+}).annotations({
+  [SCHEMA_KIND_ANNOTATION]: "commaSeparatedNumbers",
+  [PLACEHOLDER_ANNOTATION]: "1,2,3"
+});
+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(",")
+}).annotations({
+  [SCHEMA_KIND_ANNOTATION]: "commaSeparatedUrls",
+  [PLACEHOLDER_ANNOTATION]: "https://one.example.com,https://two.example.com"
+});
+var stringEnum = (values) => Schema2.Literal(...values).annotations({
+  [SCHEMA_KIND_ANNOTATION]: "stringEnum",
+  [STRING_ENUM_VALUES_ANNOTATION]: values,
+  [PLACEHOLDER_ANNOTATION]: values[0]
+});
+var json = (schema) => Schema2.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 = Redacted.make(valueToEncode);
+    }
+    const encoded = Schema3.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/cli.ts
 var DEFAULT_IO = {
   cwd: () => process.cwd(),
@@ -1069,7 +1041,7 @@ async function runAddEnv(options, io) {
   const outputPath = resolveFromCwd(cwd, options.output ?? await getDefaultEnvOutputPath(cwd));
   const source = await readTextFileOrThrow(inputPath, "input file");
   const dotenv = decodeDotenvText(source);
-  const prefix = resolvePrefix(options);
+  const prefix = resolvePrefix(options, dotenv.prefix);
   const inferred = inferModel(dotenv, { prefix });
   const generated = generateEnvTs(inferred);
   await ensureWritableTarget(outputPath, options.force);
@@ -1082,20 +1054,28 @@ async function runAddExample(options, io) {
   const defaultInput = await getDefaultExampleInputPath(cwd);
   const inputPath = resolveFromCwd(cwd, options.input ?? defaultInput);
   const outputPath = resolveFromCwd(cwd, options.output ?? ".env.example");
-  const source = await readTextFileOrThrow(inputPath, "input env.ts");
-  const manifest = decodeManifestFromSource(source);
-  const generated = generateExample(manifest);
+  process.env.ENVIL_INTROSPECT_ONLY = "1";
+  let mod;
+  try {
+    mod = await import(inputPath);
+  } finally {
+    delete process.env.ENVIL_INTROSPECT_ONLY;
+  }
+  if (!mod.envDefinition || typeof mod.envDefinition !== "object") {
+    throw new Error(`Expected "envDefinition" export in ${inputPath}. Make sure the file exports an envDefinition object.`);
+  }
+  const generated = buildEnvExample(mod.envDefinition);
   await ensureWritableTarget(outputPath, options.force);
   await writeFileAtomic(outputPath, generated);
   io.stdout(`Generated ${outputPath}
 `);
 }
-function resolvePrefix(options) {
+function resolvePrefix(options, fromDocument) {
   const fromFramework = options.framework ? FRAMEWORK_PREFIXES[options.framework] : undefined;
   return {
-    server: options.serverPrefix ?? fromFramework?.server ?? "",
-    client: options.clientPrefix ?? fromFramework?.client ?? "",
-    shared: options.sharedPrefix ?? fromFramework?.shared ?? ""
+    server: options.serverPrefix ?? fromFramework?.server ?? fromDocument?.server ?? "",
+    client: options.clientPrefix ?? fromFramework?.client ?? fromDocument?.client ?? "",
+    shared: options.sharedPrefix ?? fromFramework?.shared ?? fromDocument?.shared ?? ""
   };
 }
 function parseFlags(args, spec) {
@@ -1192,7 +1172,7 @@ function getAddHelpText() {
   return [
     "Subcommands:",
     "  envil add env      Infer env.ts from .env.example",
-    "  envil add example  Recreate .env.example from env.ts manifest",
+    "  envil add example  Recreate .env.example from env.ts",
     "",
     "Use --help on each subcommand for details.",
     ""
@@ -1245,5 +1225,5 @@ export {
   runCli
 };
 
-//# debugId=B3DBC46CBE56A44864756E2164756E21
+//# debugId=2598B6F54188F97964756E2164756E21
 //# sourceMappingURL=cli.js.map