@ayronforge/envil 0.6.0

package/dist/index.js

@@ -0,0 +1,443 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined")
+    return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/env.ts
+import { Effect, Either, ParseResult, Redacted, Schema } from "effect";
+
+// src/errors.ts
+class EnvValidationError extends Error {
+  _tag = "EnvValidationError";
+  errors;
+  constructor(errors) {
+    super(`Invalid environment variables:
+${errors.join(`
+`)}`);
+    this.name = "EnvValidationError";
+    this.errors = errors;
+  }
+}
+
+class ClientAccessError extends Error {
+  _tag = "ClientAccessError";
+  variableName;
+  constructor(variableName) {
+    super(`Attempted to access server-side env var "${variableName}" on client`);
+    this.name = "ClientAccessError";
+    this.variableName = variableName;
+  }
+}
+
+// src/prefix.ts
+function resolvePrefixMap(prefix) {
+  if (typeof prefix === "string" || prefix === undefined) {
+    const value = prefix ?? "";
+    return { server: value, client: value, shared: value };
+  }
+  return {
+    server: prefix.server ?? "",
+    client: prefix.client ?? "",
+    shared: prefix.shared ?? ""
+  };
+}
+
+// src/env.ts
+var envMetaStore = new WeakMap;
+function addToSet(target, values) {
+  for (const value of values) {
+    target.add(value);
+  }
+}
+function getEnvMeta(env) {
+  if (typeof env !== "object" || env === null) {
+    return;
+  }
+  return envMetaStore.get(env);
+}
+function normalizeRuntimeEnv(runtimeEnv, emptyStringAsUndefined) {
+  if (!emptyStringAsUndefined) {
+    return runtimeEnv;
+  }
+  return Object.fromEntries(Object.entries(runtimeEnv).map(([key, value]) => [key, value === "" ? undefined : value]));
+}
+function aggregateEnvKeys(server, client, shared, extendsEnvs) {
+  const serverKeys = new Set(Object.keys(server));
+  const clientKeys = new Set(Object.keys(client));
+  const sharedKeys = new Set(Object.keys(shared));
+  for (const ext of extendsEnvs) {
+    const meta = getEnvMeta(ext);
+    if (!meta)
+      continue;
+    addToSet(serverKeys, meta.serverKeys);
+    addToSet(clientKeys, meta.clientKeys);
+    addToSet(sharedKeys, meta.sharedKeys);
+  }
+  return { serverKeys, clientKeys, sharedKeys };
+}
+function selectSchemaForRuntime(isServer, server, client, shared) {
+  return isServer ? { ...server, ...client, ...shared } : { ...client, ...shared };
+}
+function getKeyCategory(key, client, shared) {
+  if (key in client)
+    return "client";
+  if (key in shared)
+    return "shared";
+  return "server";
+}
+function parseSchemaValues(schema, options) {
+  const values = {};
+  const errors = [];
+  for (const [key, validator] of Object.entries(schema)) {
+    const category = getKeyCategory(key, options.client, options.shared);
+    const envKey = `${options.prefixMap[category]}${key}`;
+    const rawValue = options.runtimeEnv[envKey];
+    const parsed = Schema.decodeUnknownEither(validator)(rawValue);
+    if (Either.isLeft(parsed)) {
+      const detail = ParseResult.TreeFormatter.formatErrorSync(parsed.left);
+      errors.push(`${envKey}: ${detail}`);
+      continue;
+    }
+    let finalValue = parsed.right;
+    if (options.autoRedactKeys?.has(envKey) && !Redacted.isRedacted(finalValue)) {
+      finalValue = Redacted.make(finalValue);
+    }
+    values[key] = finalValue;
+  }
+  return { values, errors };
+}
+function raiseValidationErrors(errors, onValidationError) {
+  if (errors.length === 0) {
+    return;
+  }
+  if (onValidationError) {
+    try {
+      onValidationError(errors);
+    } catch (error) {
+      throw error instanceof EnvValidationError ? error : new EnvValidationError([String(error)]);
+    }
+  }
+  throw new EnvValidationError(errors);
+}
+function mergeExtendedEnvs(extendsEnvs, parsedValues) {
+  const mergedValues = {};
+  for (const ext of extendsEnvs) {
+    for (const [key, value] of Object.entries(ext)) {
+      mergedValues[key] = value;
+    }
+  }
+  for (const [key, value] of Object.entries(parsedValues)) {
+    mergedValues[key] = value;
+  }
+  return mergedValues;
+}
+function createClientBlockedKeys(aggregated) {
+  const blockedKeys = new Set;
+  for (const key of aggregated.serverKeys) {
+    if (!aggregated.clientKeys.has(key) && !aggregated.sharedKeys.has(key)) {
+      blockedKeys.add(key);
+    }
+  }
+  return blockedKeys;
+}
+function createReadOnlyEnv(envValues, options) {
+  const frozenValues = Object.freeze(envValues);
+  return new Proxy(frozenValues, {
+    get(target, prop) {
+      if (typeof prop !== "string")
+        return;
+      if (!options.isServer && options.clientBlockedKeys.has(prop)) {
+        throw new ClientAccessError(prop);
+      }
+      return Reflect.get(target, prop);
+    },
+    set() {
+      throw new TypeError("Environment object is read-only");
+    },
+    deleteProperty() {
+      throw new TypeError("Environment object is read-only");
+    },
+    defineProperty() {
+      throw new TypeError("Environment object is read-only");
+    }
+  });
+}
+function buildEnv(opts) {
+  const extendsEnvs = opts.extends ?? [];
+  const runtimeEnv = normalizeRuntimeEnv(opts.runtimeEnv ?? process.env, opts.emptyStringAsUndefined);
+  const isServer = opts.isServer ?? typeof window === "undefined";
+  const server = opts.server ?? {};
+  const client = opts.client ?? {};
+  const shared = opts.shared ?? {};
+  const aggregated = aggregateEnvKeys(server, client, shared, extendsEnvs);
+  const prefixMap = resolvePrefixMap(opts.prefix);
+  const runtimeSchema = selectSchemaForRuntime(isServer, server, client, shared);
+  const { values: parsedValues, errors } = parseSchemaValues(runtimeSchema, {
+    client,
+    shared,
+    runtimeEnv,
+    prefixMap,
+    autoRedactKeys: opts._autoRedactKeys
+  });
+  raiseValidationErrors(errors, opts.onValidationError);
+  const mergedValues = mergeExtendedEnvs(extendsEnvs, parsedValues);
+  const clientBlockedKeys = createClientBlockedKeys(aggregated);
+  const env = createReadOnlyEnv(mergedValues, {
+    isServer,
+    clientBlockedKeys
+  });
+  envMetaStore.set(env, {
+    serverKeys: aggregated.serverKeys,
+    clientKeys: aggregated.clientKeys,
+    sharedKeys: aggregated.sharedKeys
+  });
+  return env;
+}
+function createEnv(opts) {
+  if (opts.resolvers?.length) {
+    const shouldAutoRedact = opts.autoRedactResolver !== false;
+    return Effect.all(opts.resolvers, { concurrency: "unbounded" }).pipe(Effect.map((results) => {
+      const autoRedactKeys = new Set;
+      if (shouldAutoRedact) {
+        for (const result of results) {
+          for (const [key, value] of Object.entries(result)) {
+            if (value !== undefined) {
+              autoRedactKeys.add(key);
+            }
+          }
+        }
+      }
+      return {
+        mergedEnv: Object.assign({}, opts.runtimeEnv ?? process.env, ...results),
+        autoRedactKeys
+      };
+    }), Effect.flatMap(({ mergedEnv, autoRedactKeys }) => Effect.try({
+      try: () => buildEnv({
+        ...opts,
+        runtimeEnv: mergedEnv,
+        _autoRedactKeys: shouldAutoRedact ? autoRedactKeys : undefined
+      }),
+      catch: (error) => error instanceof EnvValidationError ? error : new EnvValidationError([String(error)])
+    })));
+  }
+  return buildEnv(opts);
+}
+// src/resolvers/remote.ts
+import { Effect as Effect3 } from "effect";
+
+// src/resolvers/utils.ts
+import { Effect as Effect2 } from "effect";
+
+// src/resolvers/types.ts
+import { Data } from "effect";
+
+class ResolverError extends Data.TaggedError("ResolverError") {
+}
+
+// src/resolvers/utils.ts
+function toResolverError(resolver, message, cause) {
+  return new ResolverError({ resolver, message, cause });
+}
+function tryInitializeClient(resolver, message, initialize) {
+  return Effect2.tryPromise({
+    try: initialize,
+    catch: (cause) => toResolverError(resolver, message, cause)
+  });
+}
+function strictOrElse(effect, options) {
+  return options.strict ? effect.pipe(Effect2.mapError((cause) => toResolverError(options.resolver, options.message, cause))) : effect.pipe(Effect2.orElseSucceed(options.fallback));
+}
+function keyValueResultsToRecord(values) {
+  const result = {};
+  for (const { envKey, value } of values) {
+    result[envKey] = value;
+  }
+  return result;
+}
+function fillMissingMapValues(ids, values) {
+  for (const id of ids) {
+    if (!values.has(id)) {
+      values.set(id, undefined);
+    }
+  }
+}
+
+// src/resolvers/remote.ts
+function fromRemoteSecrets(opts) {
+  return Effect3.gen(function* () {
+    const { secrets, client, strict = false } = opts;
+    const entries = Object.entries(secrets);
+    const secretIds = entries.map(([, id]) => id);
+    const secretValues = new Map;
+    if (client.getSecrets && secretIds.length > 1) {
+      const batchResult = yield* strictOrElse(Effect3.tryPromise(() => client.getSecrets(secretIds)), {
+        strict,
+        resolver: "remote",
+        message: "Failed to resolve remote secrets batch",
+        fallback: () => new Map
+      });
+      for (const [id, value] of batchResult) {
+        secretValues.set(id, value);
+      }
+      fillMissingMapValues(secretIds, secretValues);
+    } else {
+      const results = yield* Effect3.forEach(secretIds, (secretId) => strictOrElse(Effect3.tryPromise(() => client.getSecret(secretId)), {
+        strict,
+        resolver: "remote",
+        message: `Failed to resolve remote secret "${secretId}"`,
+        fallback: () => {
+          return;
+        }
+      }).pipe(Effect3.map((value) => ({ envKey: secretId, value }))), { concurrency: "unbounded" });
+      for (const { envKey, value } of results) {
+        secretValues.set(envKey, value);
+      }
+    }
+    return keyValueResultsToRecord(entries.map(([envKey, secretId]) => ({
+      envKey,
+      value: secretValues.get(secretId)
+    })));
+  });
+}
+// src/safe-env.ts
+import { Effect as Effect4 } from "effect";
+function normalizeEnvValidationError(error) {
+  return error instanceof EnvValidationError ? error : new EnvValidationError([String(error)]);
+}
+function safeCreateEnv(opts) {
+  if (opts.resolvers !== undefined) {
+    try {
+      const created = createEnv(opts);
+      if (Effect4.isEffect(created)) {
+        const createdEffect = created;
+        return createdEffect.pipe(Effect4.match({
+          onFailure: (error) => ({ success: false, error }),
+          onSuccess: (data) => ({ success: true, data })
+        }));
+      }
+      return Effect4.succeed({ success: true, data: created });
+    } catch (error) {
+      return Effect4.succeed({
+        success: false,
+        error: normalizeEnvValidationError(error)
+      });
+    }
+  }
+  try {
+    return { success: true, data: createEnv(opts) };
+  } catch (error) {
+    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,
+  stringEnum,
+  safeCreateEnv,
+  requiredString,
+  redisUrl,
+  redacted,
+  postgresUrl,
+  positiveNumber,
+  port,
+  optionalString,
+  optional,
+  nonNegativeNumber,
+  mysqlUrl,
+  mongoUrl,
+  json,
+  integer,
+  fromRemoteSecrets,
+  createEnv,
+  commaSeparatedUrls,
+  commaSeparatedNumbers,
+  commaSeparated,
+  boolean,
+  EnvValidationError,
+  DEFAULT_VALUE_ANNOTATION,
+  ClientAccessError
+};
+
+//# debugId=83E78DCC4BD19C8E64756E2164756E21
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1,17 @@
+{
+  "version": 3,
+  "sources": ["../src/env.ts", "../src/errors.ts", "../src/prefix.ts", "../src/resolvers/remote.ts", "../src/resolvers/utils.ts", "../src/resolvers/types.ts", "../src/safe-env.ts", "../src/schemas.ts"],
+  "sourcesContent": [
+    "import { Effect, Either, ParseResult, Redacted, Schema } from \"effect\";\n\nimport { ClientAccessError, EnvValidationError } from \"./errors.ts\";\nimport { resolvePrefixMap } from \"./prefix.ts\";\nimport type { ResolverError, ResolverResult } from \"./resolvers/types.ts\";\nimport type {\n  AnyEnv,\n  EnvOptions,\n  EnvResult,\n  EnvResultAutoRedacted,\n  ExtractResolverKeys,\n  InternalEnvOptions,\n  PrefixMap,\n  PrefixStr,\n  SchemaDict,\n} from \"./types.ts\";\n\ninterface EnvMeta {\n  readonly serverKeys: ReadonlySet<string>;\n  readonly clientKeys: ReadonlySet<string>;\n  readonly sharedKeys: ReadonlySet<string>;\n}\n\ninterface AggregatedKeys {\n  serverKeys: Set<string>;\n  clientKeys: Set<string>;\n  sharedKeys: Set<string>;\n}\n\nconst envMetaStore = new WeakMap<object, EnvMeta>();\n\ntype EnvCategory = keyof Required<PrefixMap>;\n\nfunction addToSet(target: Set<string>, values: Iterable<string>) {\n  for (const value of values) {\n    target.add(value);\n  }\n}\n\nfunction getEnvMeta(env: unknown): EnvMeta | undefined {\n  if (typeof env !== \"object\" || env === null) {\n    return undefined;\n  }\n\n  return envMetaStore.get(env);\n}\n\nfunction normalizeRuntimeEnv(\n  runtimeEnv: Record<string, string | undefined>,\n  emptyStringAsUndefined: boolean | undefined,\n): Record<string, string | undefined> {\n  if (!emptyStringAsUndefined) {\n    return runtimeEnv;\n  }\n\n  return Object.fromEntries(\n    Object.entries(runtimeEnv).map(([key, value]) => [key, value === \"\" ? undefined : value]),\n  );\n}\n\nfunction aggregateEnvKeys(\n  server: SchemaDict,\n  client: SchemaDict,\n  shared: SchemaDict,\n  extendsEnvs: readonly AnyEnv[],\n): AggregatedKeys {\n  const serverKeys = new Set<string>(Object.keys(server));\n  const clientKeys = new Set<string>(Object.keys(client));\n  const sharedKeys = new Set<string>(Object.keys(shared));\n\n  for (const ext of extendsEnvs) {\n    const meta = getEnvMeta(ext);\n    if (!meta) continue;\n    addToSet(serverKeys, meta.serverKeys);\n    addToSet(clientKeys, meta.clientKeys);\n    addToSet(sharedKeys, meta.sharedKeys);\n  }\n\n  return { serverKeys, clientKeys, sharedKeys };\n}\n\nfunction selectSchemaForRuntime(\n  isServer: boolean,\n  server: SchemaDict,\n  client: SchemaDict,\n  shared: SchemaDict,\n): SchemaDict {\n  return isServer ? { ...server, ...client, ...shared } : { ...client, ...shared };\n}\n\nfunction getKeyCategory(key: string, client: SchemaDict, shared: SchemaDict): EnvCategory {\n  if (key in client) return \"client\";\n  if (key in shared) return \"shared\";\n  return \"server\";\n}\n\nfunction parseSchemaValues(\n  schema: SchemaDict,\n  options: {\n    client: SchemaDict;\n    shared: SchemaDict;\n    runtimeEnv: Record<string, string | undefined>;\n    prefixMap: Required<PrefixMap>;\n    autoRedactKeys?: ReadonlySet<string>;\n  },\n): { values: Record<string, unknown>; errors: string[] } {\n  const values: Record<string, unknown> = {};\n  const errors: string[] = [];\n\n  for (const [key, validator] of Object.entries(schema)) {\n    const category = getKeyCategory(key, options.client, options.shared);\n    const envKey = `${options.prefixMap[category]}${key}`;\n    const rawValue = options.runtimeEnv[envKey];\n    const parsed = Schema.decodeUnknownEither(validator)(rawValue);\n\n    if (Either.isLeft(parsed)) {\n      const detail = ParseResult.TreeFormatter.formatErrorSync(parsed.left);\n      errors.push(`${envKey}: ${detail}`);\n      continue;\n    }\n\n    let finalValue = parsed.right;\n    if (options.autoRedactKeys?.has(envKey) && !Redacted.isRedacted(finalValue)) {\n      finalValue = Redacted.make(finalValue);\n    }\n\n    values[key] = finalValue;\n  }\n\n  return { values, errors };\n}\n\nfunction raiseValidationErrors(\n  errors: string[],\n  onValidationError?: (errors: string[]) => void,\n): void {\n  if (errors.length === 0) {\n    return;\n  }\n\n  if (onValidationError) {\n    try {\n      onValidationError(errors);\n    } catch (error) {\n      throw error instanceof EnvValidationError ? error : new EnvValidationError([String(error)]);\n    }\n  }\n\n  throw new EnvValidationError(errors);\n}\n\nfunction mergeExtendedEnvs(\n  extendsEnvs: readonly AnyEnv[],\n  parsedValues: Record<string, unknown>,\n): Record<string, unknown> {\n  const mergedValues: Record<string, unknown> = {};\n\n  for (const ext of extendsEnvs) {\n    for (const [key, value] of Object.entries(ext)) {\n      mergedValues[key] = value;\n    }\n  }\n\n  for (const [key, value] of Object.entries(parsedValues)) {\n    mergedValues[key] = value;\n  }\n\n  return mergedValues;\n}\n\nfunction createClientBlockedKeys(aggregated: AggregatedKeys): Set<string> {\n  const blockedKeys = new Set<string>();\n\n  for (const key of aggregated.serverKeys) {\n    if (!aggregated.clientKeys.has(key) && !aggregated.sharedKeys.has(key)) {\n      blockedKeys.add(key);\n    }\n  }\n\n  return blockedKeys;\n}\n\nfunction createReadOnlyEnv<T extends AnyEnv>(\n  envValues: Record<string, unknown>,\n  options: {\n    isServer: boolean;\n    clientBlockedKeys: ReadonlySet<string>;\n  },\n): T {\n  const frozenValues = Object.freeze(envValues);\n\n  return new Proxy(frozenValues, {\n    get(target, prop) {\n      if (typeof prop !== \"string\") return undefined;\n      if (!options.isServer && options.clientBlockedKeys.has(prop)) {\n        throw new ClientAccessError(prop);\n      }\n\n      return Reflect.get(target, prop);\n    },\n    set() {\n      throw new TypeError(\"Environment object is read-only\");\n    },\n    deleteProperty() {\n      throw new TypeError(\"Environment object is read-only\");\n    },\n    defineProperty() {\n      throw new TypeError(\"Environment object is read-only\");\n    },\n  }) as T;\n}\n\nfunction buildEnv<\n  TServer extends SchemaDict = {},\n  TClient extends SchemaDict = {},\n  TShared extends SchemaDict = {},\n  const TExtends extends readonly AnyEnv[] = readonly [],\n>(\n  opts: InternalEnvOptions<TServer, TClient, TShared, TExtends>,\n): EnvResult<TExtends, TServer, TClient, TShared> {\n  const extendsEnvs = opts.extends ?? [];\n  const runtimeEnv = normalizeRuntimeEnv(\n    opts.runtimeEnv ?? process.env,\n    opts.emptyStringAsUndefined,\n  );\n  const isServer = opts.isServer ?? typeof window === \"undefined\";\n\n  const server = opts.server ?? ({} as TServer);\n  const client = opts.client ?? ({} as TClient);\n  const shared = opts.shared ?? ({} as TShared);\n\n  const aggregated = aggregateEnvKeys(server, client, shared, extendsEnvs);\n  const prefixMap = resolvePrefixMap(opts.prefix);\n  const runtimeSchema = selectSchemaForRuntime(isServer, server, client, shared);\n  const { values: parsedValues, errors } = parseSchemaValues(runtimeSchema, {\n    client,\n    shared,\n    runtimeEnv,\n    prefixMap,\n    autoRedactKeys: opts._autoRedactKeys,\n  });\n\n  raiseValidationErrors(errors, opts.onValidationError);\n\n  const mergedValues = mergeExtendedEnvs(extendsEnvs, parsedValues);\n  const clientBlockedKeys = createClientBlockedKeys(aggregated);\n  const env = createReadOnlyEnv<EnvResult<TExtends, TServer, TClient, TShared>>(mergedValues, {\n    isServer,\n    clientBlockedKeys,\n  });\n\n  envMetaStore.set(env as object, {\n    serverKeys: aggregated.serverKeys,\n    clientKeys: aggregated.clientKeys,\n    sharedKeys: aggregated.sharedKeys,\n  });\n\n  return env;\n}\n\nexport function createEnv<\n  TServer extends SchemaDict = {},\n  TClient extends SchemaDict = {},\n  TShared extends SchemaDict = {},\n  const TExtends extends readonly AnyEnv[] = readonly [],\n  const TResolvers extends readonly Effect.Effect<ResolverResult<any>, ResolverError>[] =\n    readonly [],\n>(\n  opts: EnvOptions<TServer, TClient, TShared, TExtends> & {\n    resolvers: TResolvers;\n    autoRedactResolver: false;\n  },\n): Effect.Effect<\n  EnvResult<TExtends, TServer, TClient, TShared>,\n  ResolverError | EnvValidationError\n>;\n\n// Overload: with resolvers (autoRedactResolver defaults to true) -> auto-redact resolver keys\nexport function createEnv<\n  TServer extends SchemaDict = {},\n  TClient extends SchemaDict = {},\n  TShared extends SchemaDict = {},\n  const TExtends extends readonly AnyEnv[] = readonly [],\n  const TResolvers extends readonly Effect.Effect<ResolverResult<any>, ResolverError>[] =\n    readonly [],\n  const TPrefix extends string | PrefixMap | undefined = undefined,\n>(\n  opts: EnvOptions<TServer, TClient, TShared, TExtends> & {\n    resolvers: TResolvers;\n    autoRedactResolver?: true;\n    prefix?: TPrefix;\n  },\n): Effect.Effect<\n  EnvResultAutoRedacted<\n    TExtends,\n    TServer,\n    TClient,\n    TShared,\n    ExtractResolverKeys<TResolvers>,\n    PrefixStr<TPrefix>\n  >,\n  ResolverError | EnvValidationError\n>;\n\n// Overload: without resolvers -> synchronous\nexport function createEnv<\n  TServer extends SchemaDict = {},\n  TClient extends SchemaDict = {},\n  TShared extends SchemaDict = {},\n  const TExtends extends readonly AnyEnv[] = readonly [],\n>(\n  opts: EnvOptions<TServer, TClient, TShared, TExtends>,\n): EnvResult<TExtends, TServer, TClient, TShared>;\n\nexport function createEnv(\n  opts: EnvOptions<SchemaDict, SchemaDict, SchemaDict, readonly AnyEnv[]> & {\n    resolvers?: readonly Effect.Effect<ResolverResult, ResolverError>[];\n    autoRedactResolver?: boolean;\n  },\n) {\n  if (opts.resolvers?.length) {\n    const shouldAutoRedact = opts.autoRedactResolver !== false;\n    return Effect.all(opts.resolvers, { concurrency: \"unbounded\" }).pipe(\n      Effect.map((results) => {\n        const autoRedactKeys = new Set<string>();\n        if (shouldAutoRedact) {\n          for (const result of results) {\n            for (const [key, value] of Object.entries(result)) {\n              if (value !== undefined) {\n                autoRedactKeys.add(key);\n              }\n            }\n          }\n        }\n\n        return {\n          mergedEnv: Object.assign({}, opts.runtimeEnv ?? process.env, ...results),\n          autoRedactKeys,\n        };\n      }),\n      Effect.flatMap(({ mergedEnv, autoRedactKeys }) =>\n        Effect.try({\n          try: () =>\n            buildEnv({\n              ...opts,\n              runtimeEnv: mergedEnv,\n              _autoRedactKeys: shouldAutoRedact ? autoRedactKeys : undefined,\n            }),\n          catch: (error) =>\n            error instanceof EnvValidationError ? error : new EnvValidationError([String(error)]),\n        }),\n      ),\n    );\n  }\n\n  return buildEnv(opts);\n}\n",
+    "export class EnvValidationError extends Error {\n  readonly _tag = \"EnvValidationError\" as const;\n  readonly errors: ReadonlyArray<string>;\n  constructor(errors: ReadonlyArray<string>) {\n    super(`Invalid environment variables:\\n${errors.join(\"\\n\")}`);\n    this.name = \"EnvValidationError\";\n    this.errors = errors;\n  }\n}\n\nexport class ClientAccessError extends Error {\n  readonly _tag = \"ClientAccessError\" as const;\n  readonly variableName: string;\n  constructor(variableName: string) {\n    super(`Attempted to access server-side env var \"${variableName}\" on client`);\n    this.name = \"ClientAccessError\";\n    this.variableName = variableName;\n  }\n}\n",
+    "export interface PrefixMap {\n  server?: string;\n  client?: string;\n  shared?: string;\n}\n\nexport function resolvePrefixMap(prefix: string | PrefixMap | undefined): Required<PrefixMap> {\n  if (typeof prefix === \"string\" || prefix === undefined) {\n    const value = prefix ?? \"\";\n    return { server: value, client: value, shared: value };\n  }\n\n  return {\n    server: prefix.server ?? \"\",\n    client: prefix.client ?? \"\",\n    shared: prefix.shared ?? \"\",\n  };\n}\n",
+    "import { Effect } from \"effect\";\n\nimport { ResolverError, type ResolverResult, type SecretClient } from \"./types.ts\";\nimport { fillMissingMapValues, keyValueResultsToRecord, strictOrElse } from \"./utils.ts\";\n\nexport { ResolverError } from \"./types.ts\";\n\ninterface RemoteSecretsOptions<K extends string = string> {\n  secrets: Record<K, string>;\n  client: SecretClient;\n  strict?: boolean;\n}\n\nexport function fromRemoteSecrets<K extends string>(\n  opts: RemoteSecretsOptions<K>,\n): Effect.Effect<ResolverResult<K>, ResolverError>;\nexport function fromRemoteSecrets(\n  opts: RemoteSecretsOptions,\n): Effect.Effect<ResolverResult, ResolverError> {\n  return Effect.gen(function* () {\n    const { secrets, client, strict = false } = opts;\n    const entries = Object.entries(secrets);\n    const secretIds = entries.map(([, id]) => id);\n\n    const secretValues = new Map<string, string | undefined>();\n\n    if (client.getSecrets && secretIds.length > 1) {\n      const batchResult = yield* strictOrElse(\n        Effect.tryPromise(() => client.getSecrets!(secretIds)),\n        {\n          strict,\n          resolver: \"remote\",\n          message: \"Failed to resolve remote secrets batch\",\n          fallback: () => new Map<string, string | undefined>(),\n        },\n      );\n\n      for (const [id, value] of batchResult) {\n        secretValues.set(id, value);\n      }\n      fillMissingMapValues(secretIds, secretValues);\n    } else {\n      const results = yield* Effect.forEach(\n        secretIds,\n        (secretId) =>\n          strictOrElse(\n            Effect.tryPromise(() => client.getSecret(secretId)),\n            {\n              strict,\n              resolver: \"remote\",\n              message: `Failed to resolve remote secret \"${secretId}\"`,\n              fallback: () => undefined,\n            },\n          ).pipe(Effect.map((value) => ({ envKey: secretId, value }))),\n        { concurrency: \"unbounded\" },\n      );\n\n      for (const { envKey, value } of results) {\n        secretValues.set(envKey, value);\n      }\n    }\n\n    return keyValueResultsToRecord(\n      entries.map(([envKey, secretId]) => ({\n        envKey,\n        value: secretValues.get(secretId),\n      })),\n    );\n  });\n}\n",
+    "import { Effect } from \"effect\";\n\nimport { ResolverError } from \"./types.ts\";\n\nexport function toResolverError(resolver: string, message: string, cause?: unknown): ResolverError {\n  return new ResolverError({ resolver, message, cause });\n}\n\nexport function tryInitializeClient<A>(\n  resolver: string,\n  message: string,\n  initialize: () => Promise<A>,\n): Effect.Effect<A, ResolverError> {\n  return Effect.tryPromise({\n    try: initialize,\n    catch: (cause) => toResolverError(resolver, message, cause),\n  });\n}\n\nexport function strictOrElse<A>(\n  effect: Effect.Effect<A, unknown>,\n  options: {\n    strict: boolean;\n    resolver: string;\n    message: string;\n    fallback: () => A;\n  },\n): Effect.Effect<A, ResolverError> {\n  return options.strict\n    ? effect.pipe(\n        Effect.mapError((cause) => toResolverError(options.resolver, options.message, cause)),\n      )\n    : effect.pipe(Effect.orElseSucceed(options.fallback));\n}\n\nexport function keyValueResultsToRecord<K extends string>(\n  values: ReadonlyArray<{ envKey: K; value: string | undefined }>,\n): Record<K, string | undefined> {\n  const result = {} as Record<K, string | undefined>;\n  for (const { envKey, value } of values) {\n    result[envKey] = value;\n  }\n  return result;\n}\n\nexport function fillMissingMapValues(\n  ids: readonly string[],\n  values: Map<string, string | undefined>,\n): void {\n  for (const id of ids) {\n    if (!values.has(id)) {\n      values.set(id, undefined);\n    }\n  }\n}\n",
+    "import { Data } from \"effect\";\n\nexport type ResolverResult<K extends string = string> = Record<K, string | undefined>;\n\nexport class ResolverError extends Data.TaggedError(\"ResolverError\")<{\n  readonly resolver: string;\n  readonly message: string;\n  readonly cause?: unknown;\n}> {}\n\nexport interface SecretClient {\n  getSecret: (secretId: string) => Promise<string | undefined>;\n  getSecrets?: (secretIds: string[]) => Promise<Map<string, string | undefined>>;\n}\n",
+    "import { Effect } from \"effect\";\n\nimport { createEnv } from \"./env.ts\";\nimport { EnvValidationError } from \"./errors.ts\";\nimport type { ResolverError, ResolverResult } from \"./resolvers/types.ts\";\nimport type {\n  AnyEnv,\n  EnvOptions,\n  EnvResult,\n  EnvResultAutoRedacted,\n  ExtractResolverKeys,\n  PrefixMap,\n  PrefixStr,\n  SchemaDict,\n} from \"./types.ts\";\n\nexport type SafeCreateEnvSuccess<T> = Readonly<{ success: true; data: T }>;\nexport type SafeCreateEnvFailure<E> = Readonly<{ success: false; error: E }>;\nexport type SafeCreateEnvResult<T, E> = SafeCreateEnvSuccess<T> | SafeCreateEnvFailure<E>;\n\nfunction normalizeEnvValidationError(error: unknown): EnvValidationError {\n  return error instanceof EnvValidationError ? error : new EnvValidationError([String(error)]);\n}\n\n// Overload: with resolvers + autoRedactResolver false\nexport function safeCreateEnv<\n  TServer extends SchemaDict = {},\n  TClient extends SchemaDict = {},\n  TShared extends SchemaDict = {},\n  const TExtends extends readonly AnyEnv[] = readonly [],\n  const TResolvers extends readonly Effect.Effect<ResolverResult<any>, ResolverError>[] =\n    readonly [],\n>(\n  opts: EnvOptions<TServer, TClient, TShared, TExtends> & {\n    resolvers: TResolvers;\n    autoRedactResolver: false;\n  },\n): Effect.Effect<\n  SafeCreateEnvResult<\n    EnvResult<TExtends, TServer, TClient, TShared>,\n    ResolverError | EnvValidationError\n  >,\n  never\n>;\n\n// Overload: with resolvers + autoRedactResolver true (default)\nexport function safeCreateEnv<\n  TServer extends SchemaDict = {},\n  TClient extends SchemaDict = {},\n  TShared extends SchemaDict = {},\n  const TExtends extends readonly AnyEnv[] = readonly [],\n  const TResolvers extends readonly Effect.Effect<ResolverResult<any>, ResolverError>[] =\n    readonly [],\n  const TPrefix extends string | PrefixMap | undefined = undefined,\n>(\n  opts: EnvOptions<TServer, TClient, TShared, TExtends> & {\n    resolvers: TResolvers;\n    autoRedactResolver?: true;\n    prefix?: TPrefix;\n  },\n): Effect.Effect<\n  SafeCreateEnvResult<\n    EnvResultAutoRedacted<\n      TExtends,\n      TServer,\n      TClient,\n      TShared,\n      ExtractResolverKeys<TResolvers>,\n      PrefixStr<TPrefix>\n    >,\n    ResolverError | EnvValidationError\n  >,\n  never\n>;\n\n// Overload: without resolvers + sync result object\nexport function safeCreateEnv<\n  TServer extends SchemaDict = {},\n  TClient extends SchemaDict = {},\n  TShared extends SchemaDict = {},\n  const TExtends extends readonly AnyEnv[] = readonly [],\n>(\n  opts: EnvOptions<TServer, TClient, TShared, TExtends>,\n): SafeCreateEnvResult<EnvResult<TExtends, TServer, TClient, TShared>, EnvValidationError>;\n\nexport function safeCreateEnv(\n  opts: EnvOptions<SchemaDict, SchemaDict, SchemaDict, readonly AnyEnv[]> & {\n    resolvers?: readonly Effect.Effect<ResolverResult<any>, ResolverError>[];\n    autoRedactResolver?: boolean;\n  },\n):\n  | SafeCreateEnvResult<AnyEnv, EnvValidationError>\n  | Effect.Effect<SafeCreateEnvResult<AnyEnv, ResolverError | EnvValidationError>, never> {\n  if (opts.resolvers !== undefined) {\n    try {\n      const created = createEnv(opts);\n      if (Effect.isEffect(created)) {\n        const createdEffect = created as Effect.Effect<\n          AnyEnv,\n          ResolverError | EnvValidationError,\n          never\n        >;\n\n        return createdEffect.pipe(\n          Effect.match({\n            onFailure: (error) => ({ success: false, error }) as const,\n            onSuccess: (data) => ({ success: true, data }) as const,\n          }),\n        );\n      }\n\n      return Effect.succeed({ success: true, data: created } as const);\n    } catch (error) {\n      return Effect.succeed({\n        success: false,\n        error: normalizeEnvValidationError(error),\n      } as const);\n    }\n  }\n\n  try {\n    return { success: true, data: createEnv(opts) } as const;\n  } catch (error) {\n    return { success: false, error: normalizeEnvValidationError(error) } as const;\n  }\n}\n",
+    "import { Function, Schema } from \"effect\";\n\nexport const DEFAULT_VALUE_ANNOTATION = Symbol.for(\"@ayronforge/envil/default-value\");\n\nexport const withDefault: {\n  <S extends Schema.Schema.Any>(\n    defaultValue: NonNullable<Schema.Schema.Type<S>>,\n  ): (\n    schema: S,\n  ) => Schema.transform<\n    Schema.UndefinedOr<S>,\n    Schema.SchemaClass<NonNullable<Schema.Schema.Type<S>>>\n  >;\n  <S extends Schema.Schema.Any>(\n    schema: S,\n    defaultValue: NonNullable<Schema.Schema.Type<S>>,\n  ): Schema.transform<\n    Schema.UndefinedOr<S>,\n    Schema.SchemaClass<NonNullable<Schema.Schema.Type<S>>>\n  >;\n} = Function.dual(\n  2,\n  <S extends Schema.Schema.Any>(schema: S, defaultValue: NonNullable<Schema.Schema.Type<S>>) => {\n    const withDefaultSchema = Schema.transform(\n      Schema.UndefinedOr(schema),\n      Schema.typeSchema(schema),\n      {\n        decode: (value) => value ?? defaultValue,\n        encode: (value) => value,\n      },\n    ) as Schema.transform<\n      Schema.UndefinedOr<S>,\n      Schema.SchemaClass<NonNullable<Schema.Schema.Type<S>>>\n    >;\n\n    return withDefaultSchema.annotations({\n      [DEFAULT_VALUE_ANNOTATION]: defaultValue,\n    } as Record<PropertyKey, unknown>);\n  },\n);\n\nexport const optional = <S extends Schema.Schema.Any>(schema: S) => Schema.UndefinedOr(schema);\n\nexport const redacted = <S extends Schema.Schema.Any>(schema: S) => Schema.Redacted(schema);\n\nexport const requiredString = Schema.String.pipe(Schema.minLength(1)).annotations({\n  identifier: \"RequiredString\",\n});\nexport const optionalString = Schema.UndefinedOr(Schema.String);\nexport const positiveNumber = Schema.NumberFromString.pipe(Schema.positive()).annotations({\n  identifier: \"PositiveNumber\",\n});\n\nexport const commaSeparated = Schema.transform(\n  Schema.String,\n  Schema.mutable(Schema.Array(Schema.String)),\n  {\n    decode: (s) => s.split(\",\").map((x) => x.trim()),\n    encode: (a) => a.join(\",\"),\n  },\n);\n\nexport const commaSeparatedNumbers = Schema.transform(\n  Schema.String,\n  Schema.mutable(Schema.Array(Schema.Number)),\n  {\n    decode: (s) =>\n      s.split(\",\").map((x) => {\n        const n = Number(x.trim());\n        if (Number.isNaN(n)) throw new Error(`\"${x.trim()}\" is not a valid number`);\n        return n;\n      }),\n    encode: (a) => a.join(\",\"),\n  },\n);\n\nexport const url = Schema.String.pipe(\n  Schema.filter(\n    (s) => {\n      try {\n        new URL(s);\n        return s.startsWith(\"http://\") || s.startsWith(\"https://\");\n      } catch {\n        return false;\n      }\n    },\n    { identifier: \"Url\", message: () => \"Expected a valid HTTP or HTTPS URL\" },\n  ),\n);\nexport type Url = Schema.Schema.Type<typeof url>;\n\nexport const postgresUrl = Schema.String.pipe(\n  Schema.filter((s) => s.startsWith(\"postgres://\") || s.startsWith(\"postgresql://\"), {\n    identifier: \"PostgresUrl\",\n    message: () => \"Expected a valid PostgreSQL connection URL\",\n  }),\n  Schema.pattern(/^(postgres|postgresql):\\/\\/[^:]+:[^@]+@[^:]+:\\d+\\/.+$/),\n);\nexport type PostgresUrl = Schema.Schema.Type<typeof postgresUrl>;\n\nexport const redisUrl = Schema.String.pipe(\n  Schema.filter((s) => s.startsWith(\"redis://\") || s.startsWith(\"rediss://\"), {\n    identifier: \"RedisUrl\",\n    message: () => \"Expected a valid Redis connection URL\",\n  }),\n  Schema.pattern(/^rediss?:\\/\\/(?:[^:]+:[^@]+@)?[^:]+(?::\\d+)?(?:\\/\\d+)?$/),\n);\nexport type RedisUrl = Schema.Schema.Type<typeof redisUrl>;\n\nexport const commaSeparatedUrls = Schema.transform(\n  Schema.String,\n  Schema.mutable(Schema.Array(url)),\n  {\n    decode: (s) => s.split(\",\").map((x) => Schema.decodeUnknownSync(url)(x.trim())),\n    encode: (a) => a.join(\",\"),\n  },\n);\n\nexport const boolean = Schema.transform(\n  Schema.String.pipe(\n    Schema.filter((s) => [\"true\", \"false\", \"1\", \"0\"].includes(s.toLowerCase()), {\n      identifier: \"BooleanString\",\n      message: () => \"Expected 'true', 'false', '1', or '0'\",\n    }),\n  ),\n  Schema.Boolean,\n  {\n    decode: (s) => s.toLowerCase() === \"true\" || s === \"1\",\n    encode: (b) => (b ? \"true\" : \"false\"),\n  },\n);\n\nexport const integer = Schema.NumberFromString.pipe(Schema.int()).annotations({\n  identifier: \"Integer\",\n});\n\nexport const nonNegativeNumber = Schema.NumberFromString.pipe(Schema.nonNegative()).annotations({\n  identifier: \"NonNegativeNumber\",\n});\n\nexport const port = Schema.NumberFromString.pipe(\n  Schema.int(),\n  Schema.between(1, 65535),\n).annotations({ identifier: \"Port\" });\n\nexport const stringEnum = <T extends readonly [string, ...string[]]>(values: T) =>\n  Schema.Literal(...values);\n\nexport const json = <S extends Schema.Schema.Any>(schema: S) => Schema.parseJson(schema);\n\nexport const mongoUrl = Schema.String.pipe(\n  Schema.filter((s) => s.startsWith(\"mongodb://\") || s.startsWith(\"mongodb+srv://\"), {\n    identifier: \"MongoUrl\",\n    message: () => \"Expected a valid MongoDB connection URL\",\n  }),\n  Schema.pattern(/^mongodb(\\+srv)?:\\/\\/(?:[^:]+:[^@]+@)?[^/]+(?:\\/[^?]*)?(?:\\?.*)?$/),\n);\nexport type MongoUrl = Schema.Schema.Type<typeof mongoUrl>;\n\nexport const mysqlUrl = Schema.String.pipe(\n  Schema.filter((s) => s.startsWith(\"mysql://\") || s.startsWith(\"mysqls://\"), {\n    identifier: \"MysqlUrl\",\n    message: () => \"Expected a valid MySQL connection URL\",\n  }),\n  Schema.pattern(/^mysqls?:\\/\\/[^:]+:[^@]+@[^:]+:\\d+\\/.+$/),\n);\nexport type MysqlUrl = Schema.Schema.Type<typeof mysqlUrl>;\n"
+  ],
+  "mappings": ";;;;;;;;;AAAA;;;ACAO,MAAM,2BAA2B,MAAM;AAAA,EACnC,OAAO;AAAA,EACP;AAAA,EACT,WAAW,CAAC,QAA+B;AAAA,IACzC,MAAM;AAAA,EAAmC,OAAO,KAAK;AAAA,CAAI,GAAG;AAAA,IAC5D,KAAK,OAAO;AAAA,IACZ,KAAK,SAAS;AAAA;AAElB;AAAA;AAEO,MAAM,0BAA0B,MAAM;AAAA,EAClC,OAAO;AAAA,EACP;AAAA,EACT,WAAW,CAAC,cAAsB;AAAA,IAChC,MAAM,4CAA4C,yBAAyB;AAAA,IAC3E,KAAK,OAAO;AAAA,IACZ,KAAK,eAAe;AAAA;AAExB;;;ACZO,SAAS,gBAAgB,CAAC,QAA6D;AAAA,EAC5F,IAAI,OAAO,WAAW,YAAY,WAAW,WAAW;AAAA,IACtD,MAAM,QAAQ,UAAU;AAAA,IACxB,OAAO,EAAE,QAAQ,OAAO,QAAQ,OAAO,QAAQ,MAAM;AAAA,EACvD;AAAA,EAEA,OAAO;AAAA,IACL,QAAQ,OAAO,UAAU;AAAA,IACzB,QAAQ,OAAO,UAAU;AAAA,IACzB,QAAQ,OAAO,UAAU;AAAA,EAC3B;AAAA;;;AFaF,IAAM,eAAe,IAAI;AAIzB,SAAS,QAAQ,CAAC,QAAqB,QAA0B;AAAA,EAC/D,WAAW,SAAS,QAAQ;AAAA,IAC1B,OAAO,IAAI,KAAK;AAAA,EAClB;AAAA;AAGF,SAAS,UAAU,CAAC,KAAmC;AAAA,EACrD,IAAI,OAAO,QAAQ,YAAY,QAAQ,MAAM;AAAA,IAC3C;AAAA,EACF;AAAA,EAEA,OAAO,aAAa,IAAI,GAAG;AAAA;AAG7B,SAAS,mBAAmB,CAC1B,YACA,wBACoC;AAAA,EACpC,IAAI,CAAC,wBAAwB;AAAA,IAC3B,OAAO;AAAA,EACT;AAAA,EAEA,OAAO,OAAO,YACZ,OAAO,QAAQ,UAAU,EAAE,IAAI,EAAE,KAAK,WAAW,CAAC,KAAK,UAAU,KAAK,YAAY,KAAK,CAAC,CAC1F;AAAA;AAGF,SAAS,gBAAgB,CACvB,QACA,QACA,QACA,aACgB;AAAA,EAChB,MAAM,aAAa,IAAI,IAAY,OAAO,KAAK,MAAM,CAAC;AAAA,EACtD,MAAM,aAAa,IAAI,IAAY,OAAO,KAAK,MAAM,CAAC;AAAA,EACtD,MAAM,aAAa,IAAI,IAAY,OAAO,KAAK,MAAM,CAAC;AAAA,EAEtD,WAAW,OAAO,aAAa;AAAA,IAC7B,MAAM,OAAO,WAAW,GAAG;AAAA,IAC3B,IAAI,CAAC;AAAA,MAAM;AAAA,IACX,SAAS,YAAY,KAAK,UAAU;AAAA,IACpC,SAAS,YAAY,KAAK,UAAU;AAAA,IACpC,SAAS,YAAY,KAAK,UAAU;AAAA,EACtC;AAAA,EAEA,OAAO,EAAE,YAAY,YAAY,WAAW;AAAA;AAG9C,SAAS,sBAAsB,CAC7B,UACA,QACA,QACA,QACY;AAAA,EACZ,OAAO,WAAW,KAAK,WAAW,WAAW,OAAO,IAAI,KAAK,WAAW,OAAO;AAAA;AAGjF,SAAS,cAAc,CAAC,KAAa,QAAoB,QAAiC;AAAA,EACxF,IAAI,OAAO;AAAA,IAAQ,OAAO;AAAA,EAC1B,IAAI,OAAO;AAAA,IAAQ,OAAO;AAAA,EAC1B,OAAO;AAAA;AAGT,SAAS,iBAAiB,CACxB,QACA,SAOuD;AAAA,EACvD,MAAM,SAAkC,CAAC;AAAA,EACzC,MAAM,SAAmB,CAAC;AAAA,EAE1B,YAAY,KAAK,cAAc,OAAO,QAAQ,MAAM,GAAG;AAAA,IACrD,MAAM,WAAW,eAAe,KAAK,QAAQ,QAAQ,QAAQ,MAAM;AAAA,IACnE,MAAM,SAAS,GAAG,QAAQ,UAAU,YAAY;AAAA,IAChD,MAAM,WAAW,QAAQ,WAAW;AAAA,IACpC,MAAM,SAAS,OAAO,oBAAoB,SAAS,EAAE,QAAQ;AAAA,IAE7D,IAAI,OAAO,OAAO,MAAM,GAAG;AAAA,MACzB,MAAM,SAAS,YAAY,cAAc,gBAAgB,OAAO,IAAI;AAAA,MACpE,OAAO,KAAK,GAAG,WAAW,QAAQ;AAAA,MAClC;AAAA,IACF;AAAA,IAEA,IAAI,aAAa,OAAO;AAAA,IACxB,IAAI,QAAQ,gBAAgB,IAAI,MAAM,KAAK,CAAC,SAAS,WAAW,UAAU,GAAG;AAAA,MAC3E,aAAa,SAAS,KAAK,UAAU;AAAA,IACvC;AAAA,IAEA,OAAO,OAAO;AAAA,EAChB;AAAA,EAEA,OAAO,EAAE,QAAQ,OAAO;AAAA;AAG1B,SAAS,qBAAqB,CAC5B,QACA,mBACM;AAAA,EACN,IAAI,OAAO,WAAW,GAAG;AAAA,IACvB;AAAA,EACF;AAAA,EAEA,IAAI,mBAAmB;AAAA,IACrB,IAAI;AAAA,MACF,kBAAkB,MAAM;AAAA,MACxB,OAAO,OAAO;AAAA,MACd,MAAM,iBAAiB,qBAAqB,QAAQ,IAAI,mBAAmB,CAAC,OAAO,KAAK,CAAC,CAAC;AAAA;AAAA,EAE9F;AAAA,EAEA,MAAM,IAAI,mBAAmB,MAAM;AAAA;AAGrC,SAAS,iBAAiB,CACxB,aACA,cACyB;AAAA,EACzB,MAAM,eAAwC,CAAC;AAAA,EAE/C,WAAW,OAAO,aAAa;AAAA,IAC7B,YAAY,KAAK,UAAU,OAAO,QAAQ,GAAG,GAAG;AAAA,MAC9C,aAAa,OAAO;AAAA,IACtB;AAAA,EACF;AAAA,EAEA,YAAY,KAAK,UAAU,OAAO,QAAQ,YAAY,GAAG;AAAA,IACvD,aAAa,OAAO;AAAA,EACtB;AAAA,EAEA,OAAO;AAAA;AAGT,SAAS,uBAAuB,CAAC,YAAyC;AAAA,EACxE,MAAM,cAAc,IAAI;AAAA,EAExB,WAAW,OAAO,WAAW,YAAY;AAAA,IACvC,IAAI,CAAC,WAAW,WAAW,IAAI,GAAG,KAAK,CAAC,WAAW,WAAW,IAAI,GAAG,GAAG;AAAA,MACtE,YAAY,IAAI,GAAG;AAAA,IACrB;AAAA,EACF;AAAA,EAEA,OAAO;AAAA;AAGT,SAAS,iBAAmC,CAC1C,WACA,SAIG;AAAA,EACH,MAAM,eAAe,OAAO,OAAO,SAAS;AAAA,EAE5C,OAAO,IAAI,MAAM,cAAc;AAAA,IAC7B,GAAG,CAAC,QAAQ,MAAM;AAAA,MAChB,IAAI,OAAO,SAAS;AAAA,QAAU;AAAA,MAC9B,IAAI,CAAC,QAAQ,YAAY,QAAQ,kBAAkB,IAAI,IAAI,GAAG;AAAA,QAC5D,MAAM,IAAI,kBAAkB,IAAI;AAAA,MAClC;AAAA,MAEA,OAAO,QAAQ,IAAI,QAAQ,IAAI;AAAA;AAAA,IAEjC,GAAG,GAAG;AAAA,MACJ,MAAM,IAAI,UAAU,iCAAiC;AAAA;AAAA,IAEvD,cAAc,GAAG;AAAA,MACf,MAAM,IAAI,UAAU,iCAAiC;AAAA;AAAA,IAEvD,cAAc,GAAG;AAAA,MACf,MAAM,IAAI,UAAU,iCAAiC;AAAA;AAAA,EAEzD,CAAC;AAAA;AAGH,SAAS,QAKR,CACC,MACgD;AAAA,EAChD,MAAM,cAAc,KAAK,WAAW,CAAC;AAAA,EACrC,MAAM,aAAa,oBACjB,KAAK,cAAc,QAAQ,KAC3B,KAAK,sBACP;AAAA,EACA,MAAM,WAAW,KAAK,YAAY,OAAO,WAAW;AAAA,EAEpD,MAAM,SAAS,KAAK,UAAW,CAAC;AAAA,EAChC,MAAM,SAAS,KAAK,UAAW,CAAC;AAAA,EAChC,MAAM,SAAS,KAAK,UAAW,CAAC;AAAA,EAEhC,MAAM,aAAa,iBAAiB,QAAQ,QAAQ,QAAQ,WAAW;AAAA,EACvE,MAAM,YAAY,iBAAiB,KAAK,MAAM;AAAA,EAC9C,MAAM,gBAAgB,uBAAuB,UAAU,QAAQ,QAAQ,MAAM;AAAA,EAC7E,QAAQ,QAAQ,cAAc,WAAW,kBAAkB,eAAe;AAAA,IACxE;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA,gBAAgB,KAAK;AAAA,EACvB,CAAC;AAAA,EAED,sBAAsB,QAAQ,KAAK,iBAAiB;AAAA,EAEpD,MAAM,eAAe,kBAAkB,aAAa,YAAY;AAAA,EAChE,MAAM,oBAAoB,wBAAwB,UAAU;AAAA,EAC5D,MAAM,MAAM,kBAAkE,cAAc;AAAA,IAC1F;AAAA,IACA;AAAA,EACF,CAAC;AAAA,EAED,aAAa,IAAI,KAAe;AAAA,IAC9B,YAAY,WAAW;AAAA,IACvB,YAAY,WAAW;AAAA,IACvB,YAAY,WAAW;AAAA,EACzB,CAAC;AAAA,EAED,OAAO;AAAA;AAyDF,SAAS,SAAS,CACvB,MAIA;AAAA,EACA,IAAI,KAAK,WAAW,QAAQ;AAAA,IAC1B,MAAM,mBAAmB,KAAK,uBAAuB;AAAA,IACrD,OAAO,OAAO,IAAI,KAAK,WAAW,EAAE,aAAa,YAAY,CAAC,EAAE,KAC9D,OAAO,IAAI,CAAC,YAAY;AAAA,MACtB,MAAM,iBAAiB,IAAI;AAAA,MAC3B,IAAI,kBAAkB;AAAA,QACpB,WAAW,UAAU,SAAS;AAAA,UAC5B,YAAY,KAAK,UAAU,OAAO,QAAQ,MAAM,GAAG;AAAA,YACjD,IAAI,UAAU,WAAW;AAAA,cACvB,eAAe,IAAI,GAAG;AAAA,YACxB;AAAA,UACF;AAAA,QACF;AAAA,MACF;AAAA,MAEA,OAAO;AAAA,QACL,WAAW,OAAO,OAAO,CAAC,GAAG,KAAK,cAAc,QAAQ,KAAK,GAAG,OAAO;AAAA,QACvE;AAAA,MACF;AAAA,KACD,GACD,OAAO,QAAQ,GAAG,WAAW,qBAC3B,OAAO,IAAI;AAAA,MACT,KAAK,MACH,SAAS;AAAA,WACJ;AAAA,QACH,YAAY;AAAA,QACZ,iBAAiB,mBAAmB,iBAAiB;AAAA,MACvD,CAAC;AAAA,MACH,OAAO,CAAC,UACN,iBAAiB,qBAAqB,QAAQ,IAAI,mBAAmB,CAAC,OAAO,KAAK,CAAC,CAAC;AAAA,IACxF,CAAC,CACH,CACF;AAAA,EACF;AAAA,EAEA,OAAO,SAAS,IAAI;AAAA;;AGnWtB,mBAAS;;;ACAT,mBAAS;;;ACAT;AAAA;AAIO,MAAM,sBAAsB,KAAK,YAAY,eAAe,EAIhE;AAAC;;;ADJG,SAAS,eAAe,CAAC,UAAkB,SAAiB,OAAgC;AAAA,EACjG,OAAO,IAAI,cAAc,EAAE,UAAU,SAAS,MAAM,CAAC;AAAA;AAGhD,SAAS,mBAAsB,CACpC,UACA,SACA,YACiC;AAAA,EACjC,OAAO,QAAO,WAAW;AAAA,IACvB,KAAK;AAAA,IACL,OAAO,CAAC,UAAU,gBAAgB,UAAU,SAAS,KAAK;AAAA,EAC5D,CAAC;AAAA;AAGI,SAAS,YAAe,CAC7B,QACA,SAMiC;AAAA,EACjC,OAAO,QAAQ,SACX,OAAO,KACL,QAAO,SAAS,CAAC,UAAU,gBAAgB,QAAQ,UAAU,QAAQ,SAAS,KAAK,CAAC,CACtF,IACA,OAAO,KAAK,QAAO,cAAc,QAAQ,QAAQ,CAAC;AAAA;AAGjD,SAAS,uBAAyC,CACvD,QAC+B;AAAA,EAC/B,MAAM,SAAS,CAAC;AAAA,EAChB,aAAa,QAAQ,WAAW,QAAQ;AAAA,IACtC,OAAO,UAAU;AAAA,EACnB;AAAA,EACA,OAAO;AAAA;AAGF,SAAS,oBAAoB,CAClC,KACA,QACM;AAAA,EACN,WAAW,MAAM,KAAK;AAAA,IACpB,IAAI,CAAC,OAAO,IAAI,EAAE,GAAG;AAAA,MACnB,OAAO,IAAI,IAAI,SAAS;AAAA,IAC1B;AAAA,EACF;AAAA;;;ADrCK,SAAS,iBAAiB,CAC/B,MAC8C;AAAA,EAC9C,OAAO,QAAO,IAAI,UAAU,GAAG;AAAA,IAC7B,QAAQ,SAAS,QAAQ,SAAS,UAAU;AAAA,IAC5C,MAAM,UAAU,OAAO,QAAQ,OAAO;AAAA,IACtC,MAAM,YAAY,QAAQ,IAAI,IAAI,QAAQ,EAAE;AAAA,IAE5C,MAAM,eAAe,IAAI;AAAA,IAEzB,IAAI,OAAO,cAAc,UAAU,SAAS,GAAG;AAAA,MAC7C,MAAM,cAAc,OAAO,aACzB,QAAO,WAAW,MAAM,OAAO,WAAY,SAAS,CAAC,GACrD;AAAA,QACE;AAAA,QACA,UAAU;AAAA,QACV,SAAS;AAAA,QACT,UAAU,MAAM,IAAI;AAAA,MACtB,CACF;AAAA,MAEA,YAAY,IAAI,UAAU,aAAa;AAAA,QACrC,aAAa,IAAI,IAAI,KAAK;AAAA,MAC5B;AAAA,MACA,qBAAqB,WAAW,YAAY;AAAA,IAC9C,EAAO;AAAA,MACL,MAAM,UAAU,OAAO,QAAO,QAC5B,WACA,CAAC,aACC,aACE,QAAO,WAAW,MAAM,OAAO,UAAU,QAAQ,CAAC,GAClD;AAAA,QACE;AAAA,QACA,UAAU;AAAA,QACV,SAAS,oCAAoC;AAAA,QAC7C,UAAU,MAAG;AAAA,UAAG;AAAA;AAAA,MAClB,CACF,EAAE,KAAK,QAAO,IAAI,CAAC,WAAW,EAAE,QAAQ,UAAU,MAAM,EAAE,CAAC,GAC7D,EAAE,aAAa,YAAY,CAC7B;AAAA,MAEA,aAAa,QAAQ,WAAW,SAAS;AAAA,QACvC,aAAa,IAAI,QAAQ,KAAK;AAAA,MAChC;AAAA;AAAA,IAGF,OAAO,wBACL,QAAQ,IAAI,EAAE,QAAQ,eAAe;AAAA,MACnC;AAAA,MACA,OAAO,aAAa,IAAI,QAAQ;AAAA,IAClC,EAAE,CACJ;AAAA,GACD;AAAA;;AGpEH,mBAAS;AAoBT,SAAS,2BAA2B,CAAC,OAAoC;AAAA,EACvE,OAAO,iBAAiB,qBAAqB,QAAQ,IAAI,mBAAmB,CAAC,OAAO,KAAK,CAAC,CAAC;AAAA;AAgEtF,SAAS,aAAa,CAC3B,MAMwF;AAAA,EACxF,IAAI,KAAK,cAAc,WAAW;AAAA,IAChC,IAAI;AAAA,MACF,MAAM,UAAU,UAAU,IAAI;AAAA,MAC9B,IAAI,QAAO,SAAS,OAAO,GAAG;AAAA,QAC5B,MAAM,gBAAgB;AAAA,QAMtB,OAAO,cAAc,KACnB,QAAO,MAAM;AAAA,UACX,WAAW,CAAC,WAAW,EAAE,SAAS,OAAO,MAAM;AAAA,UAC/C,WAAW,CAAC,UAAU,EAAE,SAAS,MAAM,KAAK;AAAA,QAC9C,CAAC,CACH;AAAA,MACF;AAAA,MAEA,OAAO,QAAO,QAAQ,EAAE,SAAS,MAAM,MAAM,QAAQ,CAAU;AAAA,MAC/D,OAAO,OAAO;AAAA,MACd,OAAO,QAAO,QAAQ;AAAA,QACpB,SAAS;AAAA,QACT,OAAO,4BAA4B,KAAK;AAAA,MAC1C,CAAU;AAAA;AAAA,EAEd;AAAA,EAEA,IAAI;AAAA,IACF,OAAO,EAAE,SAAS,MAAM,MAAM,UAAU,IAAI,EAAE;AAAA,IAC9C,OAAO,OAAO;AAAA,IACd,OAAO,EAAE,SAAS,OAAO,OAAO,4BAA4B,KAAK,EAAE;AAAA;AAAA;;AC3HvE,6BAAmB;AAEZ,IAAM,2BAA2B,OAAO,IAAI,iCAAiC;AAE7E,IAAM,cAgBT,SAAS,KACX,GACA,CAA8B,QAAW,iBAAqD;AAAA,EAC5F,MAAM,oBAAoB,QAAO,UAC/B,QAAO,YAAY,MAAM,GACzB,QAAO,WAAW,MAAM,GACxB;AAAA,IACE,QAAQ,CAAC,UAAU,SAAS;AAAA,IAC5B,QAAQ,CAAC,UAAU;AAAA,EACrB,CACF;AAAA,EAKA,OAAO,kBAAkB,YAAY;AAAA,KAClC,2BAA2B;AAAA,EAC9B,CAAiC;AAAA,CAErC;AAEO,IAAM,WAAW,CAA8B,WAAc,QAAO,YAAY,MAAM;AAEtF,IAAM,WAAW,CAA8B,WAAc,QAAO,SAAS,MAAM;AAEnF,IAAM,iBAAiB,QAAO,OAAO,KAAK,QAAO,UAAU,CAAC,CAAC,EAAE,YAAY;AAAA,EAChF,YAAY;AACd,CAAC;AACM,IAAM,iBAAiB,QAAO,YAAY,QAAO,MAAM;AACvD,IAAM,iBAAiB,QAAO,iBAAiB,KAAK,QAAO,SAAS,CAAC,EAAE,YAAY;AAAA,EACxF,YAAY;AACd,CAAC;AAEM,IAAM,iBAAiB,QAAO,UACnC,QAAO,QACP,QAAO,QAAQ,QAAO,MAAM,QAAO,MAAM,CAAC,GAC1C;AAAA,EACE,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,EAAE,IAAI,CAAC,MAAM,EAAE,KAAK,CAAC;AAAA,EAC/C,QAAQ,CAAC,MAAM,EAAE,KAAK,GAAG;AAC3B,CACF;AAEO,IAAM,wBAAwB,QAAO,UAC1C,QAAO,QACP,QAAO,QAAQ,QAAO,MAAM,QAAO,MAAM,CAAC,GAC1C;AAAA,EACE,QAAQ,CAAC,MACP,EAAE,MAAM,GAAG,EAAE,IAAI,CAAC,MAAM;AAAA,IACtB,MAAM,IAAI,OAAO,EAAE,KAAK,CAAC;AAAA,IACzB,IAAI,OAAO,MAAM,CAAC;AAAA,MAAG,MAAM,IAAI,MAAM,IAAI,EAAE,KAAK,0BAA0B;AAAA,IAC1E,OAAO;AAAA,GACR;AAAA,EACH,QAAQ,CAAC,MAAM,EAAE,KAAK,GAAG;AAC3B,CACF;AAEO,IAAM,MAAM,QAAO,OAAO,KAC/B,QAAO,OACL,CAAC,MAAM;AAAA,EACL,IAAI;AAAA,IACF,IAAI,IAAI,CAAC;AAAA,IACT,OAAO,EAAE,WAAW,SAAS,KAAK,EAAE,WAAW,UAAU;AAAA,IACzD,MAAM;AAAA,IACN,OAAO;AAAA;AAAA,GAGX,EAAE,YAAY,OAAO,SAAS,MAAM,qCAAqC,CAC3E,CACF;AAGO,IAAM,cAAc,QAAO,OAAO,KACvC,QAAO,OAAO,CAAC,MAAM,EAAE,WAAW,aAAa,KAAK,EAAE,WAAW,eAAe,GAAG;AAAA,EACjF,YAAY;AAAA,EACZ,SAAS,MAAM;AACjB,CAAC,GACD,QAAO,QAAQ,uDAAuD,CACxE;AAGO,IAAM,WAAW,QAAO,OAAO,KACpC,QAAO,OAAO,CAAC,MAAM,EAAE,WAAW,UAAU,KAAK,EAAE,WAAW,WAAW,GAAG;AAAA,EAC1E,YAAY;AAAA,EACZ,SAAS,MAAM;AACjB,CAAC,GACD,QAAO,QAAQ,yDAAyD,CAC1E;AAGO,IAAM,qBAAqB,QAAO,UACvC,QAAO,QACP,QAAO,QAAQ,QAAO,MAAM,GAAG,CAAC,GAChC;AAAA,EACE,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,EAAE,IAAI,CAAC,MAAM,QAAO,kBAAkB,GAAG,EAAE,EAAE,KAAK,CAAC,CAAC;AAAA,EAC9E,QAAQ,CAAC,MAAM,EAAE,KAAK,GAAG;AAC3B,CACF;AAEO,IAAM,UAAU,QAAO,UAC5B,QAAO,OAAO,KACZ,QAAO,OAAO,CAAC,MAAM,CAAC,QAAQ,SAAS,KAAK,GAAG,EAAE,SAAS,EAAE,YAAY,CAAC,GAAG;AAAA,EAC1E,YAAY;AAAA,EACZ,SAAS,MAAM;AACjB,CAAC,CACH,GACA,QAAO,SACP;AAAA,EACE,QAAQ,CAAC,MAAM,EAAE,YAAY,MAAM,UAAU,MAAM;AAAA,EACnD,QAAQ,CAAC,MAAO,IAAI,SAAS;AAC/B,CACF;AAEO,IAAM,UAAU,QAAO,iBAAiB,KAAK,QAAO,IAAI,CAAC,EAAE,YAAY;AAAA,EAC5E,YAAY;AACd,CAAC;AAEM,IAAM,oBAAoB,QAAO,iBAAiB,KAAK,QAAO,YAAY,CAAC,EAAE,YAAY;AAAA,EAC9F,YAAY;AACd,CAAC;AAEM,IAAM,OAAO,QAAO,iBAAiB,KAC1C,QAAO,IAAI,GACX,QAAO,QAAQ,GAAG,KAAK,CACzB,EAAE,YAAY,EAAE,YAAY,OAAO,CAAC;AAE7B,IAAM,aAAa,CAA2C,WACnE,QAAO,QAAQ,GAAG,MAAM;AAEnB,IAAM,OAAO,CAA8B,WAAc,QAAO,UAAU,MAAM;AAEhF,IAAM,WAAW,QAAO,OAAO,KACpC,QAAO,OAAO,CAAC,MAAM,EAAE,WAAW,YAAY,KAAK,EAAE,WAAW,gBAAgB,GAAG;AAAA,EACjF,YAAY;AAAA,EACZ,SAAS,MAAM;AACjB,CAAC,GACD,QAAO,QAAQ,mEAAmE,CACpF;AAGO,IAAM,WAAW,QAAO,OAAO,KACpC,QAAO,OAAO,CAAC,MAAM,EAAE,WAAW,UAAU,KAAK,EAAE,WAAW,WAAW,GAAG;AAAA,EAC1E,YAAY;AAAA,EACZ,SAAS,MAAM;AACjB,CAAC,GACD,QAAO,QAAQ,yCAAyC,CAC1D;",
+  "debugId": "83E78DCC4BD19C8E64756E2164756E21",
+  "names": []
+}

package/dist/prefix.d.ts

@@ -0,0 +1,6 @@
+export interface PrefixMap {
+    server?: string;
+    client?: string;
+    shared?: string;
+}
+export declare function resolvePrefixMap(prefix: string | PrefixMap | undefined): Required<PrefixMap>;

package/dist/presets.d.ts

@@ -0,0 +1,30 @@
+export declare const nextjs: {
+    readonly prefix: {
+        readonly client: "NEXT_PUBLIC_";
+    };
+};
+export declare const vite: {
+    readonly prefix: {
+        readonly client: "VITE_";
+    };
+};
+export declare const expo: {
+    readonly prefix: {
+        readonly client: "EXPO_PUBLIC_";
+    };
+};
+export declare const nuxt: {
+    readonly prefix: {
+        readonly client: "NUXT_PUBLIC_";
+    };
+};
+export declare const sveltekit: {
+    readonly prefix: {
+        readonly client: "PUBLIC_";
+    };
+};
+export declare const astro: {
+    readonly prefix: {
+        readonly client: "PUBLIC_";
+    };
+};

package/dist/presets.js

@@ -0,0 +1,26 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined")
+    return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/presets.ts
+var nextjs = { prefix: { client: "NEXT_PUBLIC_" } };
+var vite = { prefix: { client: "VITE_" } };
+var expo = { prefix: { client: "EXPO_PUBLIC_" } };
+var nuxt = { prefix: { client: "NUXT_PUBLIC_" } };
+var sveltekit = { prefix: { client: "PUBLIC_" } };
+var astro = { prefix: { client: "PUBLIC_" } };
+export {
+  vite,
+  sveltekit,
+  nuxt,
+  nextjs,
+  expo,
+  astro
+};
+
+//# debugId=A865B976E8F4D5D364756E2164756E21
+//# sourceMappingURL=presets.js.map

package/dist/presets.js.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../src/presets.ts"],
+  "sourcesContent": [
+    "export const nextjs = { prefix: { client: \"NEXT_PUBLIC_\" } } as const;\nexport const vite = { prefix: { client: \"VITE_\" } } as const;\nexport const expo = { prefix: { client: \"EXPO_PUBLIC_\" } } as const;\nexport const nuxt = { prefix: { client: \"NUXT_PUBLIC_\" } } as const;\nexport const sveltekit = { prefix: { client: \"PUBLIC_\" } } as const;\nexport const astro = { prefix: { client: \"PUBLIC_\" } } as const;\n"
+  ],
+  "mappings": ";;;;;;;;;AAAO,IAAM,SAAS,EAAE,QAAQ,EAAE,QAAQ,eAAe,EAAE;AACpD,IAAM,OAAO,EAAE,QAAQ,EAAE,QAAQ,QAAQ,EAAE;AAC3C,IAAM,OAAO,EAAE,QAAQ,EAAE,QAAQ,eAAe,EAAE;AAClD,IAAM,OAAO,EAAE,QAAQ,EAAE,QAAQ,eAAe,EAAE;AAClD,IAAM,YAAY,EAAE,QAAQ,EAAE,QAAQ,UAAU,EAAE;AAClD,IAAM,QAAQ,EAAE,QAAQ,EAAE,QAAQ,UAAU,EAAE;",
+  "debugId": "A865B976E8F4D5D364756E2164756E21",
+  "names": []
+}

package/dist/resolvers/aws.d.ts

@@ -0,0 +1,9 @@
+import { Effect } from "effect";
+import { ResolverError, type ResolverResult } from "./types.ts";
+export { ResolverError } from "./types.ts";
+interface AwsSecretsOptions<K extends string = string> {
+    secrets: Record<K, string>;
+    region?: string;
+    strict?: boolean;
+}
+export declare function fromAwsSecrets<K extends string>(opts: AwsSecretsOptions<K>): Effect.Effect<ResolverResult<K>, ResolverError>;