bini-env 1.0.10 → 1.1.1

package/README.md

@@ -3,281 +3,389 @@
 ![npm](https://img.shields.io/npm/v/bini-env?color=cyan&style=flat-square)
 ![npm downloads](https://img.shields.io/npm/dm/bini-env?style=flat-square)
 ![license](https://img.shields.io/npm/l/bini-env?style=flat-square)
-![vite](https://img.shields.io/badge/vite-%3E%3D8.0-646CFF?style=flat-square&logo=vite)
+![vite](https://img.shields.io/badge/vite-8.x-646CFF?style=flat-square&logo=vite)
+![hono](https://img.shields.io/badge/hono-4.x-E36002?style=flat-square&logo=hono)
 ![typescript](https://img.shields.io/badge/TypeScript-ready-3178C6?style=flat-square&logo=typescript)
 ![node](https://img.shields.io/badge/node-%3E%3D20.19-339933?style=flat-square&logo=node.js)
 
-**Zero-config environment variable system + Vite plugin for Bini.js**  
-Loads `.env` in development, uses host-provided variables in production, and works across Node.js, Bun, Deno, Vercel Edge, Netlify Edge, and Cloudflare Workers — without leaking secrets or adding runtime cost.
+**Zero-config environment variable system + Vite plugin for Bini.js**
 
----
-
-## ⚠️ Before You Use This
-
-This library **does NOT magically make env vars safe**.
-
-- Anything exposed to the client (`import.meta.env`) is **public**.
-- Only server-side code (`getEnv`, `requireEnv`) can safely access secrets.
-- Misconfigured prefixes = **data leak**.
-
-If you don't understand this, stop and fix that first.
+Powered by [Hono](https://hono.dev) — reads env vars from the Hono request context so variables are always resolved from the correct runtime binding, whether you're on Node.js, Bun, Deno, Vercel Edge, Netlify Edge, or Cloudflare Workers.
 
 ---
 
-## ✨ Features
+## Features
 
-- **Universal API** — `getEnv()` / `requireEnv()` work across all runtimes
-- **Zero-config `.env` loading** in development
-- **Edge-safe** — no static `fs`, `path`, or `dotenv` imports in bundles
-- **Auto server restart** — dev server restarts when `.env` files are created or changed
-- **Strict production behavior** — no file reads, no dotenv
-- **Prefix control** — supports `BINI_`, `VITE_`, or custom
-- **Tree-shakeable** — no dead code in client bundles
-- **Typed** — full TypeScript support
-- **Fast** — single load in dev, zero overhead in prod
+- **Hono-native** — `getEnv(c, key)` / `requireEnv(c, key)` read directly from the Hono request context
+- **Universal runtime** — CF Workers, Node, Bun, Deno, Vercel Edge, Netlify Edge — Hono's adapter handles all of it
+- **Zero dotenv** — no `.env` parsing at runtime; vars come from the host platform
+- **Vite-native dev** — `.env` loading, file watching, and server restarts are handled by Vite itself
+- **Dev banner** — prints `ß Bini.js (dev/preview)` and lists detected `.env` files on server start
+- **Prefix control** — `BINI_` and `VITE_` included out of the box, extend with your own
+- **Tree-shakeable** — nothing lands in the client bundle that shouldn't
+- **Typed** — full TypeScript support with an exported `HonoContext` type
 
 ---
 
-## 📦 Installation
+## Installation
 
 ```bash
-pnpm add bini-env
+pnpm add bini-env hono
 # or
-npm install bini-env
+npm install bini-env hono
 # or
-yarn add bini-env
+yarn add bini-env hono
 ```
 
+> `hono` is a required peer dependency.
+
 ---
 
-## 🚀 Quick Start
+## Quick Start
+
+**1. Register the Vite plugin**
 
 ```ts
 // vite.config.ts
-import { defineConfig } from 'vite';
-import { biniEnv } from 'bini-env';
+import { defineConfig } from 'vite'
+import { biniEnv } from 'bini-env'
 
 export default defineConfig({
   plugins: [biniEnv()]
-});
+})
 ```
 
-Done. If this doesn't work, your project setup is broken — not the plugin.
+**2. Read env vars in your Hono handlers**
 
----
+```ts
+// src/app/api/hello.ts
+import { Hono } from 'hono'
+import { getEnv, requireEnv } from 'bini-env'
 
-## 🔐 Environment Rules (Read This Twice)
+const app = new Hono()
 
-> ✅ Both `BINI_` and `VITE_` prefixes work out of the box — no extra config needed.
+app.post('/hello', async (c) => {
+  try {
+    const ctx = c as any
 
-### Client (PUBLIC)
+    // requireEnv throws if the var is missing — fail fast on required config
+    const apiKey  = requireEnv(ctx, 'MY_API_KEY')
 
-```env
-BINI_PUBLIC_API_URL=https://api.example.com
-VITE_ANALYTICS_ID=UA-XXXX
+    // getEnv returns undefined if missing — use ?? to provide a default
+    const appName = getEnv(ctx, 'APP_NAME')     ?? 'World'
+    const timeout = parseInt(getEnv(ctx, 'TIMEOUT_MS') ?? '5000')
+
+    return c.json({ message: `Hello, ${appName}!` })
+
+  } catch (error: any) {
+    if (error.message?.includes('[bini-env] Missing required')) {
+      return c.json({ error: error.message }, 500)
+    }
+    return c.json({ error: 'Something went wrong.' }, 500)
+  }
+})
+
+export default app
+```
+
+---
+
+## Usage Pattern
+
+**Always pass `c` explicitly.** Cast it once at the top of the handler, then use `ctx` throughout.
+
+```ts
+app.post('/example', async (c) => {
+  try {
+    const ctx = c as any
+
+    // Required vars — handler throws immediately if missing
+    const dbUrl  = requireEnv(ctx, 'DATABASE_URL')
+    const apiKey = requireEnv(ctx, 'STRIPE_SECRET_KEY')
+
+    // Optional vars — fall back to sensible defaults
+    const model      = getEnv(ctx, 'AI_MODEL')    ?? 'gpt-4o'
+    const region     = getEnv(ctx, 'AWS_REGION')  ?? 'us-east-1'
+    const maxRetries = parseInt(getEnv(ctx, 'MAX_RETRIES') ?? '3')
+    const debug      = getEnv(ctx, 'DEBUG_MODE')  === 'true'
+
+    // ... rest of handler
+
+  } catch (error: any) {
+    if (error.message?.includes('[bini-env] Missing required')) {
+      return c.json({ error: error.message }, 500)
+    }
+    return c.json({ error: 'Something went wrong.' }, 500)
+  }
+})
 ```
 
+**The pattern in three steps:**
+
+1. `const ctx = c as any` — once, at the top of the handler
+2. `requireEnv(ctx, 'KEY')` — for vars the handler cannot run without
+3. `getEnv(ctx, 'KEY') ?? 'default'` — for optional vars with sensible defaults
+
+---
+
+## Environment Prefixes
+
+### `BINI_` — server-side vars
+
+`BINI_` is bini-env's own prefix. Variables are **not** exposed to `import.meta.env` by default, making it the right choice for server-side config and secrets.
+
+To additionally expose a `BINI_` var to the client, add it to `envPrefix` explicitly:
+
 ```ts
-import.meta.env.BINI_PUBLIC_API_URL
+biniEnv({ envPrefix: ['BINI_', 'VITE_', 'MY_PUBLIC_'] })
 ```
 
-👉 **Never put secrets here. Ever.**
+### `VITE_` — public client vars
 
-### Server (PRIVATE)
+`VITE_` is Vite's built-in prefix. Any var starting with `VITE_` is bundled into your client-side JavaScript and is publicly visible.
 
 ```env
-SMTP_PASS=super_secret
-DATABASE_URL=postgres://...
+VITE_ANALYTICS_ID=UA-XXXX             # bundled into client JS — public
+VITE_API_URL=https://api.example.com  # bundled into client JS — public
 ```
 
 ```ts
-// getEnv and requireEnv are auto-imported in API routes
-const pass = requireEnv('SMTP_PASS');  // throws if missing
-const db   = getEnv('DATABASE_URL');   // returns undefined if missing
+// accessible anywhere, including the browser
+import.meta.env.VITE_ANALYTICS_ID
 ```
 
-👉 If this leaks, it's your fault, not the library's.
+### Choosing the right prefix
 
----
+```env
+# ✓ use VITE_ for anything the browser needs
+VITE_API_URL=https://api.example.com
 
-## 🌍 Platform Support
+# ✓ use BINI_ for server-side config
+BINI_FEATURE_FLAG=true
 
-`getEnv` and `requireEnv` work identically across every supported platform. Write your API routes once — they run everywhere unchanged.
+# ✓ no prefix for secrets — read via getEnv(ctx, key) only
+DATABASE_URL=postgres://...
+STRIPE_SECRET_KEY=sk_live_...
+```
+
+> Avoid defining the same variable under two different prefixes — your code will silently read whichever one it finds first.
 
-| Platform           | Runtime       | Where vars come from                  | How `getEnv` reads them |
-| ------------------ | ------------- | ------------------------------------- | ----------------------- |
-| Node.js            | Node          | `.env` file / system env              | `process.env` ✅         |
-| Bun                | Bun           | `.env` file / system env              | `process.env` ✅         |
-| Vercel Edge        | V8 isolate    | Project settings → Environment Vars   | `process.env` ✅         |
-| Netlify Edge       | Deno          | Site settings → Environment Vars      | `Deno.env.get()` ✅      |
-| Cloudflare Workers | V8 isolate    | `wrangler.toml [vars]` / dashboard    | `process.env` ✅         |
-| Deno Deploy        | Deno          | Project settings → Environment Vars   | `Deno.env.get()` ✅      |
+### Prefix summary
 
-> **Cloudflare note:** Variables set in `wrangler.toml [vars]` or the dashboard work with `getEnv` at the top level. Secrets added via `wrangler secret put` are only available inside the fetch handler via `c.env` — this is a Cloudflare Workers architecture constraint, not a bini-env limitation.
+| Prefix | Exposed to browser | Use for |
+|--------|--------------------|---------|
+| `BINI_` | No (unless added to `envPrefix`) | Server-side config |
+| `VITE_` | Yes, always | Public client config |
+| No prefix | No | Secrets — server only |
 
 ---
 
-## 🧠 How It Actually Works
+## Platform Support
 
-| Mode             | Behavior                                          |
-| ---------------- | ------------------------------------------------- |
-| Dev (`vite dev`) | Loads `.env` once via dynamic dotenv              |
-| Preview          | Same as dev                                       |
-| Production       | Uses `process.env` / host injection only          |
-| Deno / Netlify Edge | Uses native `Deno.env`                         |
-| Vercel / Cloudflare Edge | Uses `process.env` injected by the host  |
+`getEnv` and `requireEnv` delegate to Hono's `env(c)` adapter, which reads from the correct source on every supported platform automatically. Your code never changes regardless of where it deploys.
 
-`fs`, `path`, and `dotenv` are **never imported at the top level**. They are dynamically imported at runtime, inside Node-only guards, so edge bundlers never trace them into your bundle.
+| Platform | Runtime | Env source | How Hono reads it |
+|----------|---------|------------|-------------------|
+| Node.js | Node | System env / platform dashboard | `process.env` ✅ |
+| Bun | Bun | System env / platform dashboard | `process.env` ✅ |
+| Vercel Edge | V8 isolate | Project settings → Env Vars | `process.env` ✅ |
+| Netlify Edge | Deno | Site settings → Env Vars | `Deno.env.get()` ✅ |
+| Cloudflare Workers | V8 isolate | `wrangler.toml` / dashboard | CF bindings via `c.env` ✅ |
+| Deno Deploy | Deno | Project settings → Env Vars | `Deno.env.get()` ✅ |
+
+> **Cloudflare note:** Secrets set via `wrangler secret put` are only available inside the fetch handler via `c.env` — this is a Workers architecture constraint. `getEnv(ctx, key)` reads them correctly as long as you pass `c`.
 
 ---
 
-## 🔄 Auto Server Restart
+## How It Works
+
+### The plugin — `biniEnv()`
 
-The dev server automatically restarts when any `.env*` file is created or changed in your project root — no manual restart needed.
+Does two things: tells Vite which env prefixes to expose to `import.meta.env`, and prints the `ß Bini.js` banner with detected `.env` files when the dev or preview server starts.
 
+```ts
+// what biniEnv() does internally
+config() {
+  return { envPrefix: ['BINI_', 'VITE_', ...yourExtras] }
+}
 ```
-12:00:01 [bini-env] .env.local changed — restarting server
+
+On server start you will see:
+
 ```
+  ß Bini.js (dev)
+  ➜  Environments: .env.local, .env
+  ➜  Local:   http://localhost:3000/
+  ➜  Network: http://192.168.1.7:3000/
+```
+
+Vite handles everything else natively: loading `.env`, `.env.local`, `.env.[mode]` files during dev, watching and restarting on change, injecting prefixed vars into `import.meta.env` at build time, and HMR when env files change. bini-env does not reimplement any of that.
 
-Covered events:
-- Creating a new `.env`, `.env.local`, `.env.production`, etc.
-- Editing any existing `.env*` file
+### The env functions — `getEnv` / `requireEnv`
 
-Editor swap files (`.env.swp`, `.env~`, `.env.bak`) are ignored.
+Both functions read exclusively from `env(c)` via `hono/adapter` — the Hono request context. There are no `process.env` fallbacks. Every read is request-scoped and resolved by Hono's adapter for the current platform.
+
+`dotenv` is never used. In production, vars are set in your hosting platform's environment config.
 
 ---
 
-## ⚙️ Plugin Options
+## API Reference
+
+### `getEnv(c, key)`
+
+Returns `string | undefined`. Reads from the Hono request context.
 
 ```ts
-biniEnv({
-  enabled        : true,
-  clearViteHeader: true,
-  logo           : 'ß',
-  envPrefix      : ['BINI_', 'VITE_'],
-  loadInPreview  : true,
-});
+app.get('/config', async (c) => {
+  const ctx = c as any
+
+  const region   = getEnv(ctx, 'AWS_REGION') ?? 'us-east-1'
+  const logLevel = getEnv(ctx, 'LOG_LEVEL')  ?? 'info'
+  const debug    = getEnv(ctx, 'DEBUG_MODE') === 'true'
+
+  return c.json({ region, logLevel, debug })
+})
 ```
 
-> **Critical:** If you change `envPrefix`, you are changing what gets exposed to the browser. Break this → you leak secrets.
+### `requireEnv(c, key)`
 
----
+Returns `string`. Throws immediately if the variable is missing or empty. Logs a descriptive error to the terminal on failure.
 
-## 📚 API
+```ts
+app.post('/send-email', async (c) => {
+  try {
+    const ctx = c as any
 
-### `getEnv(key)`
+    const smtpHost = requireEnv(ctx, 'SMTP_HOST')
+    const smtpPass = requireEnv(ctx, 'SMTP_PASS')
+    const smtpPort = parseInt(getEnv(ctx, 'SMTP_PORT') ?? '587')
 
-Returns `string | undefined`. Auto-imported in API routes.
+    // ... send email
 
-Lookup order:
-1. `Deno.env.get(key)` — Deno / Netlify Edge
-2. `process.env[key]` — Node, Bun, Vercel Edge, Cloudflare Workers
-3. `import.meta.env[key]` — Vite client (prefixed variants only)
+    return c.json({ sent: true })
 
-```ts
-const debug = getEnv('DEBUG_MODE');
+  } catch (error: any) {
+    if (error.message?.includes('[bini-env] Missing required')) {
+      return c.json({ error: error.message }, 500)
+    }
+    return c.json({ error: 'Failed to send email.' }, 500)
+  }
+})
 ```
 
-### `requireEnv(key)`
-
-Same as `getEnv` but throws if missing:
+On failure, the terminal will show:
 
 ```
-[bini-env] Missing required environment variable: "SMTP_PASS"
-  → In development: add it to your .env file.
-  → In production: set it in your hosting dashboard.
+[bini-env] error  Missing required environment variable: "SMTP_HOST"
+  -> Set it in your platform's env config or hosting dashboard.
 ```
 
-Use this for anything critical that must exist at startup.
+### `biniEnv(options?)`
+
+Vite plugin. Registers `BINI_` and `VITE_` as env prefixes and optionally adds more.
 
 ```ts
-const dbUrl = requireEnv('DATABASE_URL');
+biniEnv()
+// or with extra prefixes
+biniEnv({ envPrefix: ['MY_PUBLIC_'] })
 ```
 
-### `biniEnv(options)`
+| Option | Type | Default | Description |
+|--------|------|---------|-------------|
+| `envPrefix` | `string \| string[]` | `[]` | Extra prefixes to expose to `import.meta.env`, in addition to `BINI_` and `VITE_` |
 
-Vite plugin. Handles `.env` loading, terminal output, and dev server watching.
+### `biniLogger`
 
----
+Vite-style terminal logger. Use it in your own Bini.js plugins or server-side code.
 
-## 📂 Env File Resolution Order
+```ts
+import { biniLogger } from 'bini-env'
 
-Higher entries take priority:
+biniLogger.info('Server ready')
+biniLogger.warn('Missing optional var')
+biniLogger.error('Something broke', error)
+```
 
-1. `.env.local`
-2. `.env.[mode].local`
-3. `.env.[mode]`
-4. `.env`
+### `HonoContext`
 
-Loaded once. Cached. No repeated disk reads.
+Exported type (`Context` from Hono). Use it to type helper functions that group env reads, so you only cast `c as any` once per entry point.
+
+```ts
+import type { HonoContext } from 'bini-env'
+
+function readDbConfig(c: HonoContext) {
+  const ctx = c as any
+  return {
+    url:      requireEnv(ctx, 'DATABASE_URL'),
+    poolSize: parseInt(getEnv(ctx, 'DB_POOL_SIZE') ?? '10'),
+    ssl:      getEnv(ctx, 'DB_SSL') !== 'false',
+  }
+}
+```
 
 ---
 
-## ⚡ Performance
+## Performance
 
-| Metric        | Dev       | Prod        |
-| ------------- | --------- | ----------- |
-| File Reads    | 1–5       | 0           |
-| Runtime Cost  | ~5ms once | 0           |
-| Bundle Impact | Minimal   | Tree-shaken |
+| Metric | Dev | Prod |
+|--------|-----|------|
+| File reads | 0 | 0 |
+| Runtime cost | ~0ms | 0 |
+| Bundle impact | Minimal | Tree-shaken |
 
-If you see overhead in production, you did something wrong.
+No dotenv. No disk reads. No caching layer. `getEnv` is a direct call to Hono's adapter on every invocation — request-scoped and correct.
 
 ---
 
-## 🔥 Common Failure Modes
+## Troubleshooting
 
-### "Env is undefined"
-You forgot the prefix (`BINI_` or `VITE_`) on a client-side var, or you're reading an unprefixed secret from `import.meta.env`.
+### "Env var is undefined in production"
 
-### "Works in dev, broken in prod"
-You relied on a `.env` file in production. Set vars in your hosting dashboard.
+Vars set in `.env` files are only loaded by Vite during local development. In production, set your variables in your hosting platform's environment dashboard (Vercel, Netlify, Cloudflare, etc.).
 
-### "Secrets leaked"
-You exposed them via `BINI_` or `VITE_` prefix. Those are public. Use unprefixed vars for secrets.
+### "Works in dev, undefined in prod"
 
-### "Works on Node, broken on Vercel/Netlify/Cloudflare"
-You had the old version with static `fs`/`path` imports. Upgrade — this version is edge-safe.
+Same as above. Local dev works because Vite loads `.env` files automatically. Production requires platform-level configuration.
 
 ### "Cloudflare secret not found"
-Secrets added via `wrangler secret put` are only available via `c.env` inside your handler. Use `wrangler.toml [vars]` for anything `getEnv` needs at the top level.
 
-### "Types not found"
-Add to your `tsconfig` or entry file:
-```ts
-/// <reference types="vite/client" />
-```
+Secrets set via `wrangler secret put` are only available via `c.env` inside a handler — which is exactly what `getEnv(ctx, key)` reads. Ensure you are passing `c` to the function.
 
----
+### "TypeScript error: Context not assignable to HonoContext"
 
-## 🧪 Reality Check
+Hono 4.12+ added a symbol to `HonoRequest` that can break structural assignability in strict TypeScript projects. Cast once per handler:
 
-This library is intentionally simple.
+```ts
+const ctx = c as any
+```
 
-If you need:
-- Secret rotation
-- Encrypted envs
-- Runtime validation schemas
+### "Types not found"
 
-That's **your job**, not this package.
+Add to your `tsconfig.json` or entry file:
 
----
+```ts
+/// <reference types="vite/client" />
+```
 
-## 🤝 Contributing
+---
 
-PRs welcome — but:
-- No bloat
-- No magic
-- No runtime cost
+## Compatibility
 
-If it slows startup or increases bundle size, it's getting rejected.
+| Tool | Version | Notes |
+|------|---------|-------|
+| Vite | 8.x | `envPrefix` hook is fully compatible; empty prefix array is never passed |
+| Hono | 4.x | `hono/adapter` `env()` is stable across all 4.x releases |
+| TypeScript | 5.x | Full type support via exported `HonoContext` |
+| Node.js | ≥ 20.19 | Minimum required version |
 
 ---
 
-## 📄 License
+## Contributing
 
-MIT © Bini.js Team
+PRs are welcome. The goal of this library is to stay minimal and runtime-cost-free. Contributions that add unnecessary complexity, increase bundle size, or introduce startup overhead will not be accepted.
 
 ---
 
-**Ship fast. Leak nothing. Blame config, not tooling.**
+## License
+
+MIT © Bini.js Team

package/dist/index.d.mts

@@ -1,29 +1,34 @@
+import { Context } from 'hono';
 import { Plugin } from 'vite';
 export { Plugin } from 'vite';
 
-declare function suppressDotenvLogsGlobally(): void;
+/**
+ * bini-env/src/index.ts
+ *
+ * Two responsibilities only:
+ *  1. Tell Vite which env prefixes to expose to import.meta.env  (biniEnv plugin)
+ *  2. Read env vars from the Hono request context                (getEnv / requireEnv)
+ *
+ * process.env is never used. All runtime env access goes through Hono's env() adapter,
+ * which handles Node, Bun, Cloudflare Workers, Deno, and Vercel Edge natively.
+ */
+
+/**
+ * Accepts any Hono Context. Typed against Hono's own Context rather than a
+ * loose duck type so misuse is caught at the call site.
+ */
+type HonoContext = Context;
 interface BiniEnvPluginOptions {
-    readonly enabled?: boolean;
-    readonly clearViteHeader?: boolean;
-    readonly logo?: string;
+    /** Extra prefixes to expose to import.meta.env, in addition to BINI_ and VITE_. */
     readonly envPrefix?: string | string[];
-    readonly loadInPreview?: boolean;
-    /** @deprecated Suppression is always applied at module load; this option is ignored. */
-    readonly suppressDotenvLogs?: boolean;
-}
-interface DetectedEnvFile {
-    readonly name: string;
-    readonly path: string;
 }
 declare const biniLogger: {
     readonly info: (msg: string) => void;
     readonly warn: (msg: string) => void;
     readonly error: (msg: string, err?: unknown) => void;
 };
-declare function getEnv(key: string): string | undefined;
-declare function requireEnv(key: string): string;
-declare function loadEnv(projectRoot?: string): Promise<void>;
-declare function detectEnvFiles(projectRoot?: string): DetectedEnvFile[];
+declare function getEnv(c: HonoContext, key: string): string | undefined;
+declare function requireEnv(c: HonoContext, key: string): string;
 declare function biniEnv(options?: Readonly<BiniEnvPluginOptions>): Plugin;
 
-export { type BiniEnvPluginOptions, type DetectedEnvFile, biniEnv, biniLogger, detectEnvFiles, getEnv, loadEnv, requireEnv, suppressDotenvLogsGlobally };
+export { type BiniEnvPluginOptions, type HonoContext, biniEnv, biniLogger, getEnv, requireEnv };

package/dist/index.d.ts

@@ -1,29 +1,34 @@
+import { Context } from 'hono';
 import { Plugin } from 'vite';
 export { Plugin } from 'vite';
 
-declare function suppressDotenvLogsGlobally(): void;
+/**
+ * bini-env/src/index.ts
+ *
+ * Two responsibilities only:
+ *  1. Tell Vite which env prefixes to expose to import.meta.env  (biniEnv plugin)
+ *  2. Read env vars from the Hono request context                (getEnv / requireEnv)
+ *
+ * process.env is never used. All runtime env access goes through Hono's env() adapter,
+ * which handles Node, Bun, Cloudflare Workers, Deno, and Vercel Edge natively.
+ */
+
+/**
+ * Accepts any Hono Context. Typed against Hono's own Context rather than a
+ * loose duck type so misuse is caught at the call site.
+ */
+type HonoContext = Context;
 interface BiniEnvPluginOptions {
-    readonly enabled?: boolean;
-    readonly clearViteHeader?: boolean;
-    readonly logo?: string;
+    /** Extra prefixes to expose to import.meta.env, in addition to BINI_ and VITE_. */
     readonly envPrefix?: string | string[];
-    readonly loadInPreview?: boolean;
-    /** @deprecated Suppression is always applied at module load; this option is ignored. */
-    readonly suppressDotenvLogs?: boolean;
-}
-interface DetectedEnvFile {
-    readonly name: string;
-    readonly path: string;
 }
 declare const biniLogger: {
     readonly info: (msg: string) => void;
     readonly warn: (msg: string) => void;
     readonly error: (msg: string, err?: unknown) => void;
 };
-declare function getEnv(key: string): string | undefined;
-declare function requireEnv(key: string): string;
-declare function loadEnv(projectRoot?: string): Promise<void>;
-declare function detectEnvFiles(projectRoot?: string): DetectedEnvFile[];
+declare function getEnv(c: HonoContext, key: string): string | undefined;
+declare function requireEnv(c: HonoContext, key: string): string;
 declare function biniEnv(options?: Readonly<BiniEnvPluginOptions>): Plugin;
 
-export { type BiniEnvPluginOptions, type DetectedEnvFile, biniEnv, biniLogger, detectEnvFiles, getEnv, loadEnv, requireEnv, suppressDotenvLogsGlobally };
+export { type BiniEnvPluginOptions, type HonoContext, biniEnv, biniLogger, getEnv, requireEnv };