@tmrp/env 0.1.0-alpha.0

package/LICENSE

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

package/README.md

@@ -0,0 +1,517 @@
+# @tmrp/env
+
+Type-safe environment variable parsing for TypeScript projects, powered by
+[Zod](https://zod.dev/).
+
+`@tmrp/env` reads environment variables from the current runtime or an
+explicit env-like object, validates them with Zod schemas, and returns a
+strongly typed object for application code. It supports Node.js, Deno, Bun,
+Cloudflare Workers, Vercel Edge, Netlify, browser-injected config, and
+`import.meta.env`-based toolchains.
+
+## Features
+
+- Validate environment variables with any Zod schema.
+- Infer TypeScript types from your schema definitions.
+- Fail fast when required environment variables are missing.
+- Trim string values before validation.
+- Support Node.js `process.env`, Deno `Deno.env.get`, Bun `Bun.env`, and known
+  global env records.
+- Validate explicit env records for edge runtimes, serverless bindings, browser
+  config, and `import.meta.env`.
+- Use runtime-specific entry points when you know the target runtime.
+
+## Installation
+
+```sh
+pnpm add @tmrp/env zod
+```
+
+`zod` is used directly when defining schemas. This package also depends on
+`effect` internally.
+
+## Quick Start
+
+```ts
+import { createEnv } from "@tmrp/env";
+import z from "zod";
+
+export const env = createEnv({
+  API_URL: z.url(),
+  DATABASE_URL: z.url(),
+  NODE_ENV: z.enum(["development", "test", "production"]),
+  PORT: z.coerce.number().int().positive(),
+});
+
+// Fully typed:
+env.API_URL; // string
+env.PORT; // number
+```
+
+If a variable is missing or does not match its schema, `createEnv` throws during
+initialization. This makes configuration problems visible at startup instead of
+later in application code.
+
+## Runtime Entry Points
+
+| Entry point             | Export                | Runtime behavior                                                                  |
+| ----------------------- | --------------------- | --------------------------------------------------------------------------------- |
+| `@tmrp/env`             | `createEnv`           | Detects supported runtime globals and reads from the available runtime.           |
+| `@tmrp/env/bun`         | `createBunEnv`        | Reads from Bun `Bun.env`.                                                         |
+| `@tmrp/env/node`        | `createNodeEnv`       | Reads from Node.js `process.env`.                                                 |
+| `@tmrp/env/deno`        | `createDenoEnv`       | Reads from Deno `Deno.env.get`.                                                   |
+| `@tmrp/env/record`      | `createRecordEnv`     | Reads from an explicit object.                                                    |
+| `@tmrp/env/cloudflare`  | `createCloudflareEnv` | Reads from Cloudflare Worker bindings passed to a handler.                        |
+| `@tmrp/env/vercel-edge` | `createVercelEdgeEnv` | Reads from an explicit env object in Vercel Edge code.                            |
+| `@tmrp/env/netlify`     | `createNetlifyEnv`    | Reads from an explicit Netlify env object.                                        |
+| `@tmrp/env/browser`     | `createBrowserEnv`    | Reads from an explicit browser config object.                                     |
+| `@tmrp/env/import-meta` | `createImportMetaEnv` | Reads from `import.meta.env` for Vite, Astro, SvelteKit, Nuxt, and similar tools. |
+
+## Runtime Usage
+
+### Default Runtime Detection
+
+Use `createEnv` when you want to read from whichever supported runtime globals
+are available. It checks Bun, Vercel Edge, Netlify, Node, Deno, Cloudflare
+global bindings, `import.meta.env` global shims, and browser config globals.
+
+```ts
+import { createEnv } from "@tmrp/env";
+import z from "zod";
+
+const env = createEnv({
+  SERVICE_NAME: z.string().min(1),
+});
+```
+
+For runtimes that do not expose env values through standard globals, prefer the
+explicit record entry points. The default reader also supports these optional
+global records when your application intentionally exposes them:
+
+| Global                           | Used by                                            |
+| -------------------------------- | -------------------------------------------------- |
+| `globalThis.__CLOUDFLARE_ENV__`  | Cloudflare-style bindings                          |
+| `globalThis.__IMPORT_META_ENV__` | `import.meta.env` values copied to a global record |
+| `globalThis.__APP_CONFIG__`      | Browser application config                         |
+| `globalThis.__ENV__`             | Browser application config fallback                |
+
+### Bun
+
+Use `createBunEnv` when your application runs in Bun.
+
+```ts
+import { createBunEnv } from "@tmrp/env/bun";
+import z from "zod";
+
+const env = createBunEnv({
+  DATABASE_URL: z.url(),
+  PORT: z.coerce.number().int().positive(),
+});
+```
+
+Values are read from `Bun.env`.
+
+### Node.js
+
+Use `createNodeEnv` when your application runs in Node and you want the runtime
+expectation to be explicit.
+
+```ts
+import { createNodeEnv } from "@tmrp/env/node";
+import z from "zod";
+
+const env = createNodeEnv({
+  DATABASE_URL: z.url(),
+  LOG_LEVEL: z.enum(["debug", "info", "warn", "error"]),
+});
+```
+
+Node values are read from `process.env`. If you use a local `.env` file, load it
+before creating the environment object:
+
+```ts
+import "dotenv/config";
+
+import { createNodeEnv } from "@tmrp/env/node";
+import z from "zod";
+
+const env = createNodeEnv({
+  TEST_ENV: z.string(),
+});
+```
+
+### Deno
+
+Use `createDenoEnv` when your application runs in Deno.
+
+```ts
+import { createDenoEnv } from "@tmrp/env/deno";
+import z from "zod";
+
+const env = createDenoEnv({
+  API_TOKEN: z.string().min(1),
+});
+```
+
+Deno environment access requires the appropriate permission, such as
+`--allow-env`:
+
+```sh
+deno run --allow-env src/main.ts
+```
+
+### Records And Passed Bindings
+
+Use `createRecordEnv` for env-like objects that are passed to your code instead
+of exposed globally.
+
+```ts
+import { createRecordEnv } from "@tmrp/env/record";
+import z from "zod";
+
+const env = createRecordEnv(
+  {
+    API_URL: z.url(),
+    FEATURE_ENABLED: z.coerce.boolean(),
+  },
+  runtimeEnv
+);
+```
+
+String values are trimmed before validation. Non-string values are passed
+directly to Zod, which is useful for framework-provided booleans or platform
+bindings.
+
+### Cloudflare Workers
+
+Cloudflare Workers pass bindings into handlers instead of exposing them on
+`globalThis`.
+
+```ts
+import { createCloudflareEnv } from "@tmrp/env/cloudflare";
+import z from "zod";
+
+export default {
+  fetch(request: Request, bindings: Record<string, unknown>) {
+    const env = createCloudflareEnv(
+      {
+        API_URL: z.url(),
+        API_TOKEN: z.string().min(1),
+      },
+      bindings
+    );
+
+    return fetch(env.API_URL, {
+      headers: { Authorization: `Bearer ${env.API_TOKEN}` },
+    });
+  },
+};
+```
+
+### Vercel Edge
+
+Use `createVercelEdgeEnv` with the env object available to your edge code.
+
+```ts
+import { createVercelEdgeEnv } from "@tmrp/env/vercel-edge";
+import z from "zod";
+
+const env = createVercelEdgeEnv(
+  {
+    API_URL: z.url(),
+  },
+  process.env
+);
+```
+
+### Netlify
+
+Use `createNetlifyEnv` with the env object available to your Netlify function or
+edge function.
+
+```ts
+import { createNetlifyEnv } from "@tmrp/env/netlify";
+import z from "zod";
+
+const env = createNetlifyEnv(
+  {
+    API_URL: z.url(),
+  },
+  process.env
+);
+```
+
+### Browser Config
+
+Use `createBrowserEnv` for explicit browser configuration objects. This avoids
+reading secrets from a client bundle by accident; only pass values that are safe
+to expose publicly.
+
+```ts
+import { createBrowserEnv } from "@tmrp/env/browser";
+import z from "zod";
+
+const env = createBrowserEnv(
+  {
+    PUBLIC_API_URL: z.url(),
+  },
+  globalThis.__APP_CONFIG__ as Record<string, unknown>
+);
+```
+
+### `import.meta.env`
+
+Use `createImportMetaEnv` for Vite, Astro, SvelteKit, Nuxt, and other tools that
+expose environment values through `import.meta.env`.
+
+```ts
+import { createImportMetaEnv } from "@tmrp/env/import-meta";
+import z from "zod";
+
+const env = createImportMetaEnv(
+  {
+    VITE_API_URL: z.url(),
+    DEV: z.boolean(),
+  },
+  import.meta.env
+);
+```
+
+## Defining Schemas
+
+Pass an object whose keys are environment variable names and whose values are
+Zod schemas.
+
+```ts
+const env = createEnv({
+  FEATURE_ENABLED: z.coerce.boolean(),
+  MAX_RETRIES: z.coerce.number().int().nonnegative(),
+  PUBLIC_URL: z.url(),
+  SECRET_KEY: z.string().min(32),
+});
+```
+
+The returned object is inferred from the schema object:
+
+```ts
+env.FEATURE_ENABLED; // boolean
+env.MAX_RETRIES; // number
+env.PUBLIC_URL; // string
+env.SECRET_KEY; // string
+```
+
+Runtime global values are usually strings. Use Zod coercion or transforms when
+you need booleans, numbers, dates, JSON parsing, or custom formats. Explicit
+record-based entry points can also pass non-string values directly to Zod.
+
+## Required Values
+
+All configured variables must exist in the runtime environment. Missing
+variables fail before Zod validation runs, so Zod `.optional()` and `.default()`
+schemas do not currently make an absent variable valid.
+
+```ts
+const env = createEnv({
+  REQUIRED_TOKEN: z.string().min(1),
+  LOG_LEVEL: z.enum(["debug", "info", "warn", "error"]),
+});
+```
+
+If you need defaults, define them in the runtime environment before calling
+`createEnv`:
+
+```ts
+process.env.LOG_LEVEL ??= "info";
+
+const env = createEnv({
+  LOG_LEVEL: z.enum(["debug", "info", "warn", "error"]),
+});
+```
+
+## Error Behavior
+
+All creators run synchronously and throw on failure.
+
+Missing variable error:
+
+```txt
+Environment variable "DATABASE_URL" is not defined
+```
+
+Validation error:
+
+```txt
+Environment variable "PORT" failed validation: ...
+```
+
+This behavior is intentional: configuration errors should fail application
+startup immediately.
+
+## Example `.env`
+
+```dotenv
+TEST_ENV="this-is-a-test-value"
+DATABASE_URL="https://example.com/database"
+PORT="3000"
+NODE_ENV="development"
+```
+
+An example file is included at `.env.example`.
+
+## API Reference
+
+### `createEnv(envKeys)`
+
+Reads variables from the detected Bun, Node, or Deno runtime and validates them.
+
+```ts
+function createEnv<const TEnvKeys extends Record<string, ZodType>>(
+  envKeys: TEnvKeys
+): { [K in keyof TEnvKeys]: z.infer<TEnvKeys[K]> };
+```
+
+Use this from `@tmrp/env`.
+
+### `createBunEnv(envKeys)`
+
+Reads variables from Bun `Bun.env` and validates them.
+
+```ts
+function createBunEnv<const TEnvKeys extends Record<string, ZodType>>(
+  envKeys: TEnvKeys
+): { [K in keyof TEnvKeys]: z.infer<TEnvKeys[K]> };
+```
+
+Use this from `@tmrp/env/bun`.
+
+### `createNodeEnv(envKeys)`
+
+Reads variables from Node.js `process.env` and validates them.
+
+```ts
+function createNodeEnv<const TEnvKeys extends Record<string, ZodType>>(
+  envKeys: TEnvKeys
+): { [K in keyof TEnvKeys]: z.infer<TEnvKeys[K]> };
+```
+
+Use this from `@tmrp/env/node`.
+
+### `createDenoEnv(envKeys)`
+
+Reads variables from Deno `Deno.env.get` and validates them.
+
+```ts
+function createDenoEnv<const TEnvKeys extends Record<string, ZodType>>(
+  envKeys: TEnvKeys
+): { [K in keyof TEnvKeys]: z.infer<TEnvKeys[K]> };
+```
+
+Use this from `@tmrp/env/deno`.
+
+### `createRecordEnv(envKeys, record)`
+
+Reads variables from an explicit object and validates them.
+
+```ts
+function createRecordEnv<const TEnvKeys extends Record<string, ZodType>>(
+  envKeys: TEnvKeys,
+  record: Record<string, unknown>
+): { [K in keyof TEnvKeys]: z.infer<TEnvKeys[K]> };
+```
+
+Use this from `@tmrp/env/record`.
+
+### Platform Record Creators
+
+These entry points all use the same explicit-record validation model, but expose
+runtime-specific names for clearer application code:
+
+| Entry point             | Function                                      |
+| ----------------------- | --------------------------------------------- |
+| `@tmrp/env/cloudflare`  | `createCloudflareEnv(envKeys, bindings)`      |
+| `@tmrp/env/vercel-edge` | `createVercelEdgeEnv(envKeys, env)`           |
+| `@tmrp/env/netlify`     | `createNetlifyEnv(envKeys, env)`              |
+| `@tmrp/env/browser`     | `createBrowserEnv(envKeys, env)`              |
+| `@tmrp/env/import-meta` | `createImportMetaEnv(envKeys, importMetaEnv)` |
+
+## Development
+
+This repository uses pnpm and TypeScript.
+
+### Requirements
+
+- Node.js 24.x
+- pnpm
+
+The repository includes `.nvmrc` and `.npmrc` files for local Node version
+alignment.
+
+### Install Dependencies
+
+```sh
+pnpm install
+```
+
+### Typecheck
+
+```sh
+pnpm typecheck
+```
+
+### Lint
+
+```sh
+pnpm lint
+```
+
+### Test
+
+```sh
+pnpm test
+pnpm test:coverage
+```
+
+Coverage thresholds are 100% for statements, branches, functions, and lines.
+
+### Build
+
+```sh
+pnpm build
+```
+
+## Project Structure
+
+```txt
+src/
+  create-env.ts                         Default runtime-aware environment creator
+  index.ts                              Default public export
+  effects/                              Internal Effect-based read and parse pipeline
+  lib/                                  Shared schemas and types
+  runtime/
+    browser/                            Browser config entry point
+    bun/                                Bun-specific entry point and reader
+    cloudflare/                         Cloudflare bindings entry point
+    deno/                               Deno-specific entry point and reader
+    import-meta/                        import.meta.env entry point
+    netlify/                            Netlify env object entry point
+    node/                               Node-specific entry point and reader
+    record/                             Generic record/object entry point
+    vercel/                             Vercel Edge env object entry point
+```
+
+## Notes And Limitations
+
+- Values from strings are trimmed before validation.
+- Reads are synchronous.
+- The package validates configuration at creation time, not lazily.
+- Runtime global values are usually strings; explicit records can also pass
+  non-string values to Zod.
+- Missing environment variables currently fail before Zod defaults can be
+  applied.
+- Browser and build-tool entry points validate values you explicitly pass to
+  them. The default reader can also use the documented global records when your
+  application intentionally exposes them.
+
+## License
+
+MIT

package/dist/create-env.d.ts

@@ -0,0 +1,31 @@
+import type { EnvKeys } from "./lib/types.js";
+/**
+ * Creates a typed environment object from the currently available runtime.
+ *
+ * Use this entry point when your code can run across multiple supported
+ * runtimes, or when you do not want to bind the call site to a runtime-specific
+ * reader. The default reader detects supported globals such as Bun, Node, Deno,
+ * Vercel Edge, Netlify, Cloudflare-style global bindings, import-meta global
+ * shims, and browser config globals.
+ *
+ * For runtimes that pass env values directly to handlers, prefer the explicit
+ * record-based runtime helpers when possible.
+ *
+ * @example
+ * ```ts
+ * import { createEnv } from "@tmrp/env/default";
+ * import z from "zod";
+ *
+ * const env = createEnv({
+ *   API_URL: z.url(),
+ *   NODE_ENV: z.enum(["development", "test", "production"]),
+ *   PORT: z.coerce.number().int().positive(),
+ * });
+ * ```
+ *
+ * @param envKeys Environment variable names mapped to Zod schemas.
+ * @returns A strongly typed object inferred from `envKeys`.
+ * @throws When a configured variable is missing or fails validation.
+ */
+export declare function createEnv<const TEnvKeys extends EnvKeys>(envKeys: TEnvKeys): import("./lib/types.js").Env<TEnvKeys>;
+//# sourceMappingURL=create-env.d.ts.map

package/dist/create-env.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-env.d.ts","sourceRoot":"","sources":["../src/create-env.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,gBAAgB,CAAC;AAM9C;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,SAAS,CAAC,KAAK,CAAC,QAAQ,SAAS,OAAO,EAAE,OAAO,EAAE,QAAQ,0CAE1E"}

package/dist/create-env.js

@@ -0,0 +1,35 @@
+import { createEnvEffect } from "./effects/create-env-effect.js";
+import { readEnvEffect } from "./effects/read-env-effect.js";
+import { RuntimeGlobalsSchema } from "./lib/schema.js";
+/**
+ * Creates a typed environment object from the currently available runtime.
+ *
+ * Use this entry point when your code can run across multiple supported
+ * runtimes, or when you do not want to bind the call site to a runtime-specific
+ * reader. The default reader detects supported globals such as Bun, Node, Deno,
+ * Vercel Edge, Netlify, Cloudflare-style global bindings, import-meta global
+ * shims, and browser config globals.
+ *
+ * For runtimes that pass env values directly to handlers, prefer the explicit
+ * record-based runtime helpers when possible.
+ *
+ * @example
+ * ```ts
+ * import { createEnv } from "@tmrp/env/default";
+ * import z from "zod";
+ *
+ * const env = createEnv({
+ *   API_URL: z.url(),
+ *   NODE_ENV: z.enum(["development", "test", "production"]),
+ *   PORT: z.coerce.number().int().positive(),
+ * });
+ * ```
+ *
+ * @param envKeys Environment variable names mapped to Zod schemas.
+ * @returns A strongly typed object inferred from `envKeys`.
+ * @throws When a configured variable is missing or fails validation.
+ */
+export function createEnv(envKeys) {
+    return createEnvEffect(envKeys, RuntimeGlobalsSchema, readEnvEffect);
+}
+//# sourceMappingURL=create-env.js.map

package/dist/create-env.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-env.js","sourceRoot":"","sources":["../src/create-env.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,eAAe,EAAE,MAAM,gCAAgC,CAAC;AACjE,OAAO,EAAE,aAAa,EAAE,MAAM,8BAA8B,CAAC;AAC7D,OAAO,EAAE,oBAAoB,EAAE,MAAM,iBAAiB,CAAC;AAEvD;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,MAAM,UAAU,SAAS,CAAiC,OAAiB;IACzE,OAAO,eAAe,CAAC,OAAO,EAAE,oBAAoB,EAAE,aAAa,CAAC,CAAC;AACvE,CAAC"}

package/dist/effects/create-env-effect.d.ts

@@ -0,0 +1,4 @@
+import type { RuntimeGlobalsSchemaType } from "../lib/schema.js";
+import type { Env, EnvKeys } from "../lib/types.js";
+export declare function createEnvEffect<const TEnvKeys extends EnvKeys>(envKeys: TEnvKeys, runtimeSchema: RuntimeGlobalsSchemaType, runtimeEnvReadEffect: (key: string, schema: RuntimeGlobalsSchemaType) => unknown): Env<TEnvKeys>;
+//# sourceMappingURL=create-env-effect.d.ts.map

package/dist/effects/create-env-effect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-env-effect.d.ts","sourceRoot":"","sources":["../../src/effects/create-env-effect.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,kBAAkB,CAAC;AACjE,OAAO,KAAK,EAAE,GAAG,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAKpD,wBAAgB,eAAe,CAAC,KAAK,CAAC,QAAQ,SAAS,OAAO,EAC5D,OAAO,EAAE,QAAQ,EACjB,aAAa,EAAE,wBAAwB,EACvC,oBAAoB,EAAE,CACpB,GAAG,EAAE,MAAM,EACX,MAAM,EAAE,wBAAwB,KAC7B,OAAO,GAaE,GAAG,CAAC,QAAQ,CAAC,CAC5B"}

package/dist/effects/create-env-effect.js

@@ -0,0 +1,8 @@
+import { Effect } from "effect";
+import { envParseValueEffect } from "./env-parse-value-effect.js";
+import { envReadValueEffect } from "./env-read-value-effect.js";
+export function createEnvEffect(envKeys, runtimeSchema, runtimeEnvReadEffect) {
+    const env = Effect.runSync(Effect.forEach(Object.entries(envKeys), ([key, schema]) => envReadValueEffect(key, (env) => runtimeEnvReadEffect(env, runtimeSchema)).pipe(Effect.flatMap((value) => envParseValueEffect(key, schema, value)), Effect.map((value) => [key, value]))).pipe(Effect.map((entries) => Object.fromEntries(entries))));
+    return env;
+}
+//# sourceMappingURL=create-env-effect.js.map

package/dist/effects/create-env-effect.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-env-effect.js","sourceRoot":"","sources":["../../src/effects/create-env-effect.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAKhC,OAAO,EAAE,mBAAmB,EAAE,MAAM,6BAA6B,CAAC;AAClE,OAAO,EAAE,kBAAkB,EAAE,MAAM,4BAA4B,CAAC;AAEhE,MAAM,UAAU,eAAe,CAC7B,OAAiB,EACjB,aAAuC,EACvC,oBAGY;IAEZ,MAAM,GAAG,GAAG,MAAM,CAAC,OAAO,CACxB,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC,CAAC,GAAG,EAAE,MAAM,CAAC,EAAE,EAAE,CACxD,kBAAkB,CAAC,GAAG,EAAE,CAAC,GAAG,EAAE,EAAE,CAC9B,oBAAoB,CAAC,GAAG,EAAE,aAAa,CAAC,CACzC,CAAC,IAAI,CACJ,MAAM,CAAC,OAAO,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,mBAAmB,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,CAAC,CAAC,EAClE,MAAM,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC,GAAG,EAAE,KAAK,CAAU,CAAC,CAC7C,CACF,CAAC,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,MAAM,CAAC,WAAW,CAAC,OAAO,CAAC,CAAC,CAAC,CAC7D,CAAC;IAEF,OAAO,GAAoB,CAAC;AAC9B,CAAC"}

package/dist/effects/env-parse-value-effect.d.ts

@@ -0,0 +1,4 @@
+import type { ZodType } from "zod";
+import { Effect } from "effect";
+export declare const envParseValueEffect: (key: string, schema: ZodType, value: unknown) => Effect.Effect<unknown, Error, never>;
+//# sourceMappingURL=env-parse-value-effect.d.ts.map

package/dist/effects/env-parse-value-effect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"env-parse-value-effect.d.ts","sourceRoot":"","sources":["../../src/effects/env-parse-value-effect.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,KAAK,CAAC;AAEnC,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAEhC,eAAO,MAAM,mBAAmB,GAC9B,KAAK,MAAM,EACX,QAAQ,OAAO,EACf,OAAO,OAAO,yCAQZ,CAAC"}

package/dist/effects/env-parse-value-effect.js

@@ -0,0 +1,8 @@
+import { Effect } from "effect";
+export const envParseValueEffect = (key, schema, value) => Effect.try({
+    try: () => schema.parse(value),
+    catch: (error) => new Error(`Environment variable "${key}" failed validation: ${error}`, {
+        cause: error,
+    }),
+});
+//# sourceMappingURL=env-parse-value-effect.js.map

package/dist/effects/env-parse-value-effect.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"env-parse-value-effect.js","sourceRoot":"","sources":["../../src/effects/env-parse-value-effect.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAEhC,MAAM,CAAC,MAAM,mBAAmB,GAAG,CACjC,GAAW,EACX,MAAe,EACf,KAAc,EACd,EAAE,CACF,MAAM,CAAC,GAAG,CAAC;IACT,GAAG,EAAE,GAAG,EAAE,CAAC,MAAM,CAAC,KAAK,CAAC,KAAK,CAAC;IAC9B,KAAK,EAAE,CAAC,KAAK,EAAE,EAAE,CACf,IAAI,KAAK,CAAC,yBAAyB,GAAG,wBAAwB,KAAK,EAAE,EAAE;QACrE,KAAK,EAAE,KAAK;KACb,CAAC;CACL,CAAC,CAAC"}

package/dist/effects/env-read-value-effect.d.ts

@@ -0,0 +1,6 @@
+import { Effect } from "effect";
+type Key = string;
+type readRuntimeEnvEffect = (key: Key) => unknown;
+export declare const envReadValueEffect: (key: Key, readRuntimeEnvEffect: readRuntimeEnvEffect) => Effect.Effect<{}, Error, never>;
+export {};
+//# sourceMappingURL=env-read-value-effect.d.ts.map

package/dist/effects/env-read-value-effect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"env-read-value-effect.d.ts","sourceRoot":"","sources":["../../src/effects/env-read-value-effect.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAEhC,KAAK,GAAG,GAAG,MAAM,CAAC;AAElB,KAAK,oBAAoB,GAAG,CAAC,GAAG,EAAE,GAAG,KAAK,OAAO,CAAC;AAElD,eAAO,MAAM,kBAAkB,GAC7B,KAAK,GAAG,EACR,sBAAsB,oBAAoB,oCAMzC,CAAC"}

package/dist/effects/env-read-value-effect.js

@@ -0,0 +1,3 @@
+import { Effect } from "effect";
+export const envReadValueEffect = (key, readRuntimeEnvEffect) => Effect.fromNullable(readRuntimeEnvEffect(key)).pipe(Effect.mapError(() => new Error(`Environment variable "${key}" is not defined`)));
+//# sourceMappingURL=env-read-value-effect.js.map

package/dist/effects/env-read-value-effect.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"env-read-value-effect.js","sourceRoot":"","sources":["../../src/effects/env-read-value-effect.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAMhC,MAAM,CAAC,MAAM,kBAAkB,GAAG,CAChC,GAAQ,EACR,oBAA0C,EAC1C,EAAE,CACF,MAAM,CAAC,YAAY,CAAC,oBAAoB,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,CACjD,MAAM,CAAC,QAAQ,CACb,GAAG,EAAE,CAAC,IAAI,KAAK,CAAC,yBAAyB,GAAG,kBAAkB,CAAC,CAChE,CACF,CAAC"}