@emergente-labs/effect-env 0.1.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Emergente Labs
+
+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,80 @@
+# @emergente-labs/effect-env
+
+Type-safe environment variable configuration for [Effect-TS](https://effect.website) applications. The "T3 env" equivalent for Effect -- clean DX, per-environment defaults, proxy access, and test helpers.
+
+## Installation
+
+```bash
+npm install @emergente-labs/effect-env effect
+```
+
+## Quick Start
+
+```typescript
+import { createEnv } from "@emergente-labs/effect-env";
+import { Config, Effect, Redacted } from "effect";
+
+const { env, requiredSecrets } = createEnv({
+  vars: {
+    // Required in all environments
+    databaseUrl: Config.redacted("DATABASE_URL"),
+    
+    // Optional in development, required in production
+    apiKey: [Config.string("API_KEY"), "dev-key-123"] as const,
+    
+    // Number config with default
+    port: [Config.number("PORT"), 3000] as const,
+  },
+});
+
+// requiredSecrets = ["DATABASE_URL"]
+
+// Access individual variables
+const program = Effect.gen(function* () {
+  const dbUrl = yield* env.databaseUrl;      // Redacted<string>
+  const key = yield* env.apiKey;             // string
+  const port = yield* env.port;              // number
+  
+  // Or access all at once
+  const all = yield* env;
+  // { databaseUrl: Redacted<string>, apiKey: string, port: number }
+});
+```
+
+## API
+
+### `createEnv(options)`
+
+Creates a typed environment configuration from a record of Config definitions.
+
+Each variable can be:
+- `Config.Config<T>` -- required in all environments
+- `[Config.Config<T>, T] as const` -- required only in production, uses default in dev/test
+
+Returns `{ env, requiredSecrets }`:
+- `env` -- dual-access proxy: `yield* env.key` for individual values, `yield* env` for all
+- `requiredSecrets` -- array of env var names that must be set in production
+
+### `createEnvVar(config, defaultValueInDevelopment?)`
+
+Lower-level function for creating individual environment-aware configs.
+
+### `createTestEnvLayer(envMap)`
+
+Creates an Effect Layer that provides mock environment variables for testing.
+
+```typescript
+import { createTestEnvLayer } from "@emergente-labs/effect-env";
+
+const testLayer = createTestEnvLayer({
+  DATABASE_URL: "postgresql://localhost:5432/test",
+  NODE_ENV: "test",
+});
+
+// Use in tests
+const result = yield* myEffect.pipe(Effect.provide(testLayer));
+```
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1,121 @@
+import { Config, Layer } from 'effect';
+
+/** A config with no default (required in all environments) */
+type RequiredConfig<T> = Config.Config<T>;
+/** A config with a default value (required only in production) */
+type OptionalConfig<T> = readonly [Config.Config<T>, T];
+/** Union of both config types */
+type EnvVarDefinition<T = unknown> = RequiredConfig<T> | OptionalConfig<T>;
+/**
+ * The input record type for `createEnv`. Each key maps to either:
+ * - `Config.Config<T>` - required in all environments
+ * - `readonly [Config.Config<T>, T]` - required only in production, uses default in development
+ *
+ * @example
+ * const vars: EnvVarsInput = {
+ *   databaseUrl: Config.redacted("DATABASE_URL"),
+ *   apiKey: [Config.string("API_KEY"), "dev-key"] as const,
+ * };
+ */
+type EnvVarsInput = Record<string, EnvVarDefinition>;
+/** Extract the success type from a config definition */
+type ExtractConfigType<T> = T extends OptionalConfig<infer U> ? U : T extends RequiredConfig<infer U> ? U : never;
+/** Map input record to resolved Config types */
+type ResolvedEnvVars<T extends EnvVarsInput> = {
+    [K in keyof T]: Config.Config<ExtractConfigType<T[K]>>;
+};
+/** The resolved plain values object */
+type ResolvedEnvValues<T extends EnvVarsInput> = {
+    [K in keyof T]: ExtractConfigType<T[K]>;
+};
+/** The proxy type that allows both `yield* env.key` and `yield* env` */
+type EnvProxy<T extends EnvVarsInput> = Config.Config<ResolvedEnvValues<T>> & ResolvedEnvVars<T>;
+/** The env proxy combined with metadata about required secrets */
+interface CreateEnvReturn<EnvVars extends EnvVarsInput> {
+    /** The env proxy that supports `yield* env.key` and `yield* env` */
+    readonly env: EnvProxy<EnvVars>;
+    /** Environment variable names that are required (no default value) */
+    readonly requiredSecrets: readonly string[];
+}
+/**
+ * Options for `createEnv`.
+ *
+ * @template EnvVars - The record of environment variable definitions
+ */
+interface CreateEnvOptions<EnvVars extends EnvVarsInput> {
+    /** Record of environment variable definitions */
+    vars: EnvVars;
+}
+
+/**
+ * Creates a typed environment configuration from a record of Config definitions.
+ *
+ * Each variable can be defined as:
+ * - `Config.Config<T>` - required in all environments
+ * - `[Config.Config<T>, T] as const` - required only in production, uses the
+ *   provided default value in development/test environments
+ *
+ * @template EnvVars - The record of environment variable definitions
+ *
+ * @param options - Configuration options
+ * @param options.vars - Record of environment variable definitions
+ *
+ * @returns An object containing:
+ *   - `env`: An Effect Config proxy that supports both `yield* env.key` for
+ *     individual values and `yield* env` for all values.
+ *   - `requiredSecrets`: Array of environment variable names that are required
+ *     (no default value) and must be set for deployment.
+ *
+ * @example
+ * const { env, requiredSecrets } = createEnv({
+ *   vars: {
+ *     databaseUrl: Config.redacted("DATABASE_URL"),
+ *     apiKey: [Config.string("API_KEY"), "dev-key-123"] as const,
+ *   },
+ * });
+ *
+ * // requiredSecrets = ["DATABASE_URL"]
+ *
+ * // In an Effect generator:
+ * const dbUrl = yield* env.databaseUrl;  // Redacted
+ * const key = yield* env.apiKey;         // string
+ * const all = yield* env;                // { databaseUrl: Redacted, apiKey: string }
+ */
+declare function createEnv<EnvVars extends EnvVarsInput>(options: CreateEnvOptions<EnvVars>): CreateEnvReturn<EnvVars>;
+
+/**
+ * Creates an environment variable configuration with optional development fallback.
+ *
+ * @template T - The type of the environment variable value
+ * @param config - The Config instance to read the environment variable
+ * @param defaultValueInDevelopment - Optional default value to use in non-production environments.
+ *   - If provided: Variable is required only in production, uses default in development
+ *   - If omitted: Variable is required in all environments
+ * @returns A Config that validates the environment variable based on the current NODE_ENV
+ *
+ * @example
+ * // Required in all environments (no default)
+ * const dbUrl = createEnvVar(Config.string("DATABASE_URL"));
+ *
+ * @example
+ * // Required only in production, uses default in development
+ * const apiKey = createEnvVar(Config.string("API_KEY"), "dev-key-123");
+ */
+declare function createEnvVar<T>(config: Config.Config<T>, defaultValueInDevelopment?: T): Config.Config<T>;
+
+/**
+ * Creates a test layer with a given set of environment variables.
+ * Useful for testing code that depends on environment variables.
+ *
+ * @param envMap - A Map or Record of environment variable names to their values
+ * @returns A Layer that provides the environment variables to the Effect runtime
+ *
+ * @example
+ * const testLayer = createTestEnvLayer(new Map([
+ *   ["DATABASE_URL", "postgresql://user:password@localhost:5432/db"],
+ *   ["NODE_ENV", "test"],
+ * ]));
+ */
+declare function createTestEnvLayer(envMap: Map<string, string> | Record<string, string>): Layer.Layer<never>;
+
+export { type CreateEnvOptions, type CreateEnvReturn, type EnvProxy, type EnvVarsInput, type ResolvedEnvValues, type ResolvedEnvVars, createEnv, createEnvVar, createTestEnvLayer };

package/dist/index.js

@@ -0,0 +1,142 @@
+// src/createEnv.ts
+import { Config as Config2 } from "effect";
+
+// src/createEnvVar.ts
+import { Config, Option, ConfigError, Either, Schema } from "effect";
+var environment = Config.string("NODE_ENV");
+var configSchema = Schema.Union(
+  Schema.Struct({
+    name: Schema.String
+  }),
+  Schema.Struct({
+    original: Schema.suspend(() => configSchema)
+  }),
+  Schema.Struct({
+    config: Schema.suspend(() => configSchema)
+  }),
+  Schema.Struct({
+    first: Schema.suspend(() => configSchema),
+    second: Schema.suspend(() => configSchema)
+  })
+);
+var extractPath = (v) => {
+  if ("name" in v) {
+    return [v.name];
+  }
+  if ("original" in v) {
+    const extracted = extractPath(v.original);
+    if (extracted.length) {
+      return extracted;
+    }
+  }
+  if ("first" in v) {
+    const first = extractPath(v.first);
+    if (first.length > 0) return first;
+    return extractPath(v.second);
+  }
+  if ("config" in v) {
+    const extracted = extractPath(v.config);
+    if (extracted.length) {
+      return extracted;
+    }
+  }
+  return [];
+};
+function getConfigPath(config) {
+  const decoded = Schema.decodeUnknownEither(configSchema)(config);
+  return Either.match(decoded, {
+    onLeft: () => [],
+    onRight: extractPath
+  });
+}
+function createMissingDataError(config, optionalInDevelopment) {
+  const path = getConfigPath(config);
+  const message = optionalInDevelopment ? "Environment variable required in production" : "Environment variable required in all environments";
+  return ConfigError.MissingData(path, message);
+}
+function isValueRequired(env, optionalInDevelopment) {
+  if (optionalInDevelopment) {
+    return env === "production";
+  }
+  return true;
+}
+function createEnvVar(config, defaultValueInDevelopment) {
+  const optionalInDevelopment = defaultValueInDevelopment !== void 0;
+  return Config.all({
+    env: environment,
+    value: Config.option(config)
+  }).pipe(
+    Config.mapOrFail(({ env, value }) => {
+      const isRequired = isValueRequired(env, optionalInDevelopment);
+      if (isRequired && Option.isNone(value)) {
+        return Either.left(createMissingDataError(config, optionalInDevelopment));
+      }
+      return Either.right(
+        Option.getOrElse(() => defaultValueInDevelopment)(value)
+      );
+    })
+  );
+}
+
+// src/createEnv.ts
+function isOptionalConfig(value) {
+  return Array.isArray(value) && value.length === 2;
+}
+function hasName(config) {
+  return "name" in config && typeof config.name === "string";
+}
+function hasOriginal(config) {
+  return "original" in config && config.original !== null && typeof config.original === "object";
+}
+function hasFirst(config) {
+  return "first" in config && config.first !== null && typeof config.first === "object";
+}
+function extractConfigName(config) {
+  if (hasName(config)) return config.name;
+  if (hasOriginal(config)) return extractConfigName(config.original);
+  if (hasFirst(config)) return extractConfigName(config.first);
+  return void 0;
+}
+function createEnv(options) {
+  const processedVars = {};
+  const requiredSecrets = [];
+  for (const key of Object.keys(options.vars)) {
+    const value = options.vars[key];
+    if (value === void 0) continue;
+    if (isOptionalConfig(value)) {
+      processedVars[key] = createEnvVar(value[0], value[1]);
+    } else {
+      processedVars[key] = createEnvVar(value);
+      const envVarName = extractConfigName(value);
+      if (envVarName) {
+        requiredSecrets.push(envVarName);
+      }
+    }
+  }
+  const allEnvVars = Config2.all(processedVars);
+  const env = new Proxy(allEnvVars, {
+    get(target, prop) {
+      if (typeof prop === "string" && prop in processedVars) {
+        return Config2.map(
+          target,
+          (allValues) => allValues[prop]
+        );
+      }
+      return target[prop];
+    }
+  });
+  return { env, requiredSecrets };
+}
+
+// src/createTestEnvLayer.ts
+import { Layer, ConfigProvider } from "effect";
+function createTestEnvLayer(envMap) {
+  const map = envMap instanceof Map ? envMap : new Map(Object.entries(envMap));
+  return Layer.setConfigProvider(ConfigProvider.fromMap(map));
+}
+export {
+  createEnv,
+  createEnvVar,
+  createTestEnvLayer
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/createEnv.ts","../src/createEnvVar.ts","../src/createTestEnvLayer.ts"],"sourcesContent":["import { Config } from \"effect\";\nimport { createEnvVar } from \"./createEnvVar\";\nimport type {\n  EnvVarsInput,\n  EnvVarDefinition,\n  OptionalConfig,\n  CreateEnvOptions,\n  CreateEnvReturn,\n  ResolvedEnvValues,\n  EnvProxy,\n} from \"./types\";\n\nfunction isOptionalConfig<T>(\n  value: EnvVarDefinition<T>,\n): value is OptionalConfig<T> {\n  return Array.isArray(value) && value.length === 2;\n}\n\n/** Config with a direct name property (primitive configs like string, number, etc.) */\ninterface ConfigWithName {\n  readonly name: string;\n}\n\n/** Config that wraps another config (mapped, validated, branded) */\ninterface ConfigWithOriginal {\n  readonly original: Config.Config<unknown>;\n}\n\n/** Config with a fallback (orElse, withDefault) */\ninterface ConfigWithFirst {\n  readonly first: Config.Config<unknown>;\n}\n\nfunction hasName(config: Config.Config<unknown>): config is Config.Config<unknown> & ConfigWithName {\n  return \"name\" in config && typeof config.name === \"string\";\n}\n\nfunction hasOriginal(config: Config.Config<unknown>): config is Config.Config<unknown> & ConfigWithOriginal {\n  return \"original\" in config && config.original !== null && typeof config.original === \"object\";\n}\n\nfunction hasFirst(config: Config.Config<unknown>): config is Config.Config<unknown> & ConfigWithFirst {\n  return \"first\" in config && config.first !== null && typeof config.first === \"object\";\n}\n\n/**\n * Extracts the environment variable name from a Config object.\n * Works with nested, mapped, validated, and other transformed configs.\n */\nfunction extractConfigName(config: Config.Config<unknown>): string | undefined {\n  if (hasName(config)) return config.name;\n  if (hasOriginal(config)) return extractConfigName(config.original);\n  if (hasFirst(config)) return extractConfigName(config.first);\n  return undefined;\n}\n\n/**\n * Creates a typed environment configuration from a record of Config definitions.\n *\n * Each variable can be defined as:\n * - `Config.Config<T>` - required in all environments\n * - `[Config.Config<T>, T] as const` - required only in production, uses the\n *   provided default value in development/test environments\n *\n * @template EnvVars - The record of environment variable definitions\n *\n * @param options - Configuration options\n * @param options.vars - Record of environment variable definitions\n *\n * @returns An object containing:\n *   - `env`: An Effect Config proxy that supports both `yield* env.key` for\n *     individual values and `yield* env` for all values.\n *   - `requiredSecrets`: Array of environment variable names that are required\n *     (no default value) and must be set for deployment.\n *\n * @example\n * const { env, requiredSecrets } = createEnv({\n *   vars: {\n *     databaseUrl: Config.redacted(\"DATABASE_URL\"),\n *     apiKey: [Config.string(\"API_KEY\"), \"dev-key-123\"] as const,\n *   },\n * });\n *\n * // requiredSecrets = [\"DATABASE_URL\"]\n *\n * // In an Effect generator:\n * const dbUrl = yield* env.databaseUrl;  // Redacted\n * const key = yield* env.apiKey;         // string\n * const all = yield* env;                // { databaseUrl: Redacted, apiKey: string }\n */\nexport function createEnv<EnvVars extends EnvVarsInput>(\n  options: CreateEnvOptions<EnvVars>,\n): CreateEnvReturn<EnvVars> {\n  const processedVars: Record<string, Config.Config<unknown>> = {};\n  const requiredSecrets: string[] = [];\n\n  for (const key of Object.keys(options.vars)) {\n    const value = options.vars[key];\n    if (value === undefined) continue;\n\n    if (isOptionalConfig(value)) {\n      // Tuple: [Config, defaultValue] - optional, has a default\n      processedVars[key] = createEnvVar(value[0], value[1]);\n    } else {\n      // Just a Config (required in all environments)\n      processedVars[key] = createEnvVar(value);\n      // Extract the env var name for required secrets\n      const envVarName = extractConfigName(value);\n      if (envVarName) {\n        requiredSecrets.push(envVarName);\n      }\n    }\n  }\n\n  const allEnvVars = Config.all(processedVars) as Config.Config<\n    ResolvedEnvValues<EnvVars>\n  >;\n\n  const env = new Proxy(allEnvVars, {\n    get(target, prop: string | symbol) {\n      if (typeof prop === \"string\" && prop in processedVars) {\n        return Config.map(\n          target,\n          (allValues) => allValues[prop as keyof typeof allValues],\n        );\n      }\n      return target[prop as keyof typeof target];\n    },\n  }) as EnvProxy<EnvVars>;\n\n  return { env, requiredSecrets };\n}\n","import { Config, Option, ConfigError, Either, Schema } from \"effect\";\n\nconst environment = Config.string(\"NODE_ENV\");\n\n/* walker to get the path from a config type that has transformations, like `Config.string(\"SECRET_KEY\").pipe(Config.array)` */\ninterface ConfigName {\n  name: string;\n}\n\ninterface ConfigOriginal {\n  original: ConfigType;\n}\n\ninterface ConfigFirstSecond {\n  first: ConfigType;\n  second: ConfigType;\n}\n\ninterface ConfigBuried {\n  config: ConfigType;\n}\n\ntype ConfigType =\n  | ConfigName\n  | ConfigOriginal\n  | ConfigFirstSecond\n  | ConfigBuried;\n\nconst configSchema = Schema.Union(\n  Schema.Struct({\n    name: Schema.String,\n  }),\n  Schema.Struct({\n    original: Schema.suspend((): Schema.Schema<ConfigType> => configSchema),\n  }),\n  Schema.Struct({\n    config: Schema.suspend((): Schema.Schema<ConfigType> => configSchema),\n  }),\n  Schema.Struct({\n    first: Schema.suspend((): Schema.Schema<ConfigType> => configSchema),\n    second: Schema.suspend((): Schema.Schema<ConfigType> => configSchema),\n  }),\n);\n\nconst extractPath = (v: typeof configSchema.Type): string[] => {\n  if (\"name\" in v) {\n    return [v.name];\n  }\n\n  if (\"original\" in v) {\n    const extracted = extractPath(v.original);\n    if (extracted.length) {\n      return extracted;\n    }\n  }\n\n  if (\"first\" in v) {\n    const first = extractPath(v.first);\n    if (first.length > 0) return first;\n    return extractPath(v.second);\n  }\n\n  if (\"config\" in v) {\n    const extracted = extractPath(v.config);\n    if (extracted.length) {\n      return extracted;\n    }\n  }\n\n  return [];\n};\n/* end of walker */\n\nfunction getConfigPath(config: Config.Config<unknown>): string[] {\n  const decoded = Schema.decodeUnknownEither(configSchema)(config);\n  return Either.match(decoded, {\n    onLeft: () => [],\n    onRight: extractPath,\n  });\n}\n\nfunction createMissingDataError(\n  config: Config.Config<unknown>,\n  optionalInDevelopment: boolean,\n): ConfigError.ConfigError {\n  const path = getConfigPath(config);\n  const message = optionalInDevelopment\n    ? \"Environment variable required in production\"\n    : \"Environment variable required in all environments\";\n  return ConfigError.MissingData(path, message);\n}\n\nfunction isValueRequired(env: string, optionalInDevelopment: boolean): boolean {\n  if (optionalInDevelopment) {\n    return env === \"production\";\n  }\n  return true;\n}\n\n/**\n * Creates an environment variable configuration with optional development fallback.\n *\n * @template T - The type of the environment variable value\n * @param config - The Config instance to read the environment variable\n * @param defaultValueInDevelopment - Optional default value to use in non-production environments.\n *   - If provided: Variable is required only in production, uses default in development\n *   - If omitted: Variable is required in all environments\n * @returns A Config that validates the environment variable based on the current NODE_ENV\n *\n * @example\n * // Required in all environments (no default)\n * const dbUrl = createEnvVar(Config.string(\"DATABASE_URL\"));\n *\n * @example\n * // Required only in production, uses default in development\n * const apiKey = createEnvVar(Config.string(\"API_KEY\"), \"dev-key-123\");\n */\nexport function createEnvVar<T>(\n  config: Config.Config<T>,\n  defaultValueInDevelopment?: T,\n): Config.Config<T> {\n  const optionalInDevelopment = defaultValueInDevelopment !== undefined;\n\n  return Config.all({\n    env: environment,\n    value: Config.option(config),\n  }).pipe(\n    Config.mapOrFail(({ env, value }) => {\n      const isRequired = isValueRequired(env, optionalInDevelopment);\n\n      if (isRequired && Option.isNone(value)) {\n        return Either.left(createMissingDataError(config, optionalInDevelopment));\n      }\n\n      return Either.right(\n        Option.getOrElse(() => defaultValueInDevelopment as T)(value),\n      );\n    }),\n  );\n}\n","import { Layer, ConfigProvider } from \"effect\";\n\n/**\n * Creates a test layer with a given set of environment variables.\n * Useful for testing code that depends on environment variables.\n *\n * @param envMap - A Map or Record of environment variable names to their values\n * @returns A Layer that provides the environment variables to the Effect runtime\n *\n * @example\n * const testLayer = createTestEnvLayer(new Map([\n *   [\"DATABASE_URL\", \"postgresql://user:password@localhost:5432/db\"],\n *   [\"NODE_ENV\", \"test\"],\n * ]));\n */\nexport function createTestEnvLayer(\n  envMap: Map<string, string> | Record<string, string>,\n): Layer.Layer<never> {\n  const map = envMap instanceof Map ? envMap : new Map(Object.entries(envMap));\n  return Layer.setConfigProvider(ConfigProvider.fromMap(map));\n}\n"],"mappings":"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","names":["Config","Config"]}

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@emergente-labs/effect-env",
+  "version": "0.1.1",
+  "description": "Type-safe Effect-TS environment variable configuration with development fallbacks",
+  "type": "module",
+  "license": "MIT",
+  "author": "Emergente Labs",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/emergente-labs/effect-env"
+  },
+  "bugs": "https://github.com/emergente-labs/effect-env/issues",
+  "homepage": "https://github.com/emergente-labs/effect-env#readme",
+  "keywords": ["effect", "effect-ts", "environment", "config", "env", "type-safe", "typed-env"],
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "files": ["dist", "README.md", "LICENSE"],
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "scripts": {
+    "prepare": "pnpm build",
+    "build": "tsup",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "typecheck": "tsc --noEmit",
+    "prepublishOnly": "pnpm run build && pnpm run test"
+  },
+  "dependencies": {
+    "effect": "^3.19.8"
+  },
+  "devDependencies": {
+    "@effect/vitest": "^0.27.0",
+    "tsup": "^8.4.0",
+    "typescript": "^5.9.3",
+    "vitest": "^4.0.16"
+  }
+}