@ojolowoblue/lamba 1.0.0

package/dist/integrations/react.mjs

@@ -0,0 +1,1488 @@
+// src/integrations/react.ts
+import { useState, useEffect } from "react";
+
+// src/core/preset-manager.ts
+var STORAGE_PRESETS_KEY = "__lamba_presets__";
+var STORAGE_ACTIVE_PRESET_KEY = "__lamba_active_preset__";
+var PresetManager = class {
+  constructor() {
+    this.presets = [];
+    this.activePresetId = null;
+    this.loadFromStorage();
+  }
+  loadFromStorage() {
+    if (typeof localStorage === "undefined") return;
+    try {
+      const rawPresets = localStorage.getItem(STORAGE_PRESETS_KEY);
+      if (rawPresets) {
+        this.presets = JSON.parse(rawPresets);
+      }
+      this.activePresetId = localStorage.getItem(STORAGE_ACTIVE_PRESET_KEY);
+    } catch (e) {
+      console.warn("[lamba] Failed to parse presets from localStorage", e);
+    }
+  }
+  saveToStorage() {
+    if (typeof localStorage === "undefined") return;
+    try {
+      localStorage.setItem(STORAGE_PRESETS_KEY, JSON.stringify(this.presets));
+      if (this.activePresetId) {
+        localStorage.setItem(STORAGE_ACTIVE_PRESET_KEY, this.activePresetId);
+      } else {
+        localStorage.removeItem(STORAGE_ACTIVE_PRESET_KEY);
+      }
+    } catch (e) {
+      console.warn("[lamba] Failed to save presets to localStorage", e);
+    }
+  }
+  getPresets() {
+    return [...this.presets];
+  }
+  getActivePresetId() {
+    return this.activePresetId;
+  }
+  createPreset(name, overrides) {
+    const newPreset = {
+      id: "preset_" + Math.random().toString(36).substring(2, 9),
+      name: name.trim() || "Untitled Preset",
+      overrides: { ...overrides },
+      createdAt: Date.now()
+    };
+    this.presets.push(newPreset);
+    this.saveToStorage();
+    return newPreset;
+  }
+  deletePreset(id) {
+    this.presets = this.presets.filter((p) => p.id !== id);
+    if (this.activePresetId === id) {
+      this.activePresetId = null;
+    }
+    this.saveToStorage();
+  }
+  setActivePreset(id) {
+    if (!id) {
+      this.activePresetId = null;
+      this.saveToStorage();
+      return null;
+    }
+    const preset = this.presets.find((p) => p.id === id);
+    if (preset) {
+      this.activePresetId = id;
+      this.saveToStorage();
+      return preset;
+    }
+    return null;
+  }
+};
+
+// src/core/env-parser.ts
+function parseEnvString(rawText) {
+  const result = {};
+  const lines = rawText.split("\n");
+  for (let line of lines) {
+    line = line.trim();
+    if (!line || line.startsWith("#")) continue;
+    if (line.startsWith("export ")) {
+      line = line.slice(7).trim();
+    }
+    const equalsIdx = line.indexOf("=");
+    if (equalsIdx === -1) continue;
+    const key = line.slice(0, equalsIdx).trim();
+    let val = line.slice(equalsIdx + 1).trim();
+    if (val.startsWith('"') && val.endsWith('"') || val.startsWith("'") && val.endsWith("'")) {
+      val = val.slice(1, -1);
+    }
+    val = val.replace(/\\n/g, "\n");
+    if (key) {
+      result[key] = val;
+    }
+  }
+  return result;
+}
+function stringifyEnv(env) {
+  return Object.entries(env).map(([key, val]) => {
+    const needsQuotes = val.includes(" ") || val.includes("\n") || val.includes("#");
+    const formattedVal = needsQuotes ? `"${val.replace(/"/g, '\\"')}"` : val;
+    return `${key}=${formattedVal}`;
+  }).join("\n");
+}
+function autoDiscoverBrowserEnv() {
+  const discovered = {};
+  if (typeof window === "undefined") return discovered;
+  try {
+    const winProcess = window.process;
+    if (winProcess && winProcess.env && typeof winProcess.env === "object") {
+      for (const [k, v] of Object.entries(winProcess.env)) {
+        if (typeof v === "string" || typeof v === "number" || typeof v === "boolean") {
+          discovered[k] = String(v);
+        }
+      }
+    }
+  } catch (e) {
+  }
+  try {
+    const customEnv = window.__ENV__ || window.ENV;
+    if (customEnv && typeof customEnv === "object") {
+      for (const [k, v] of Object.entries(customEnv)) {
+        if (typeof v === "string" || typeof v === "number" || typeof v === "boolean") {
+          discovered[k] = String(v);
+        }
+      }
+    }
+  } catch (e) {
+  }
+  try {
+    const metaTags = document.querySelectorAll("meta");
+    metaTags.forEach((meta) => {
+      const name = meta.getAttribute("name");
+      const content = meta.getAttribute("content");
+      if (!name || content === null) return;
+      if (name.startsWith("env:")) {
+        const key = name.slice(4);
+        discovered[key] = content;
+      } else if (name === "lamba-env") {
+        const parsed = new URLSearchParams(content);
+        parsed.forEach((val, key) => {
+          discovered[key] = val;
+        });
+      }
+    });
+  } catch (e) {
+  }
+  return discovered;
+}
+async function tryFetchRootEnvFile() {
+  const paths = ["/.env", "/.env.local", "/.env.example"];
+  for (const path of paths) {
+    try {
+      const res = await fetch(path, { headers: { Accept: "text/plain" } });
+      if (res.ok) {
+        const text = await res.text();
+        if (text && text.includes("=")) {
+          return parseEnvString(text);
+        }
+      }
+    } catch (e) {
+    }
+  }
+  return {};
+}
+
+// src/core/store.ts
+var STORAGE_OVERRIDES_KEY = "__lamba_overrides__";
+var DEFAULT_SECRET_PATTERN = /(KEY|SECRET|TOKEN|PASSWORD|AUTH|PRIVATE|CREDENTIAL|SIGNATURE)/i;
+var EnvStore = class {
+  constructor(options = {}) {
+    this.variables = /* @__PURE__ */ new Map();
+    this.overrides = {};
+    this.envChangeListeners = /* @__PURE__ */ new Set();
+    this.storeChangeListeners = /* @__PURE__ */ new Set();
+    this.secretPattern = options.secretKeysPattern || DEFAULT_SECRET_PATTERN;
+    this.presetManager = new PresetManager();
+    this.loadOverridesFromStorage();
+    if (options.env) {
+      this.mergeDefaults(options.env);
+    }
+    const autoDiscovered = autoDiscoverBrowserEnv();
+    this.mergeDefaults(autoDiscovered);
+    if (options.autoFetchEnvFile === true && typeof window !== "undefined") {
+      tryFetchRootEnvFile().then((fileEnv) => {
+        if (Object.keys(fileEnv).length > 0) {
+          this.mergeDefaults(fileEnv);
+        }
+      });
+    }
+    this.patchProcessEnv();
+  }
+  loadOverridesFromStorage() {
+    if (typeof localStorage === "undefined") return;
+    try {
+      const stored = localStorage.getItem(STORAGE_OVERRIDES_KEY);
+      if (stored) {
+        this.overrides = JSON.parse(stored);
+      }
+    } catch (e) {
+      console.warn("[lamba] Failed to parse overrides from localStorage", e);
+    }
+  }
+  saveOverridesToStorage() {
+    if (typeof localStorage === "undefined") return;
+    try {
+      localStorage.setItem(STORAGE_OVERRIDES_KEY, JSON.stringify(this.overrides));
+    } catch (e) {
+      console.warn("[lamba] Failed to save overrides to localStorage", e);
+    }
+  }
+  /**
+   * Monkey-patches window.process.env to reactively return overridden values.
+   */
+  patchProcessEnv() {
+    if (typeof window === "undefined") return;
+    const win = window;
+    if (!win.process) {
+      win.process = { env: {} };
+    } else if (!win.process.env) {
+      win.process.env = {};
+    }
+    const self = this;
+    const targetEnv = win.process.env;
+    try {
+      win.process.env = new Proxy(targetEnv, {
+        get(target, prop) {
+          if (typeof prop === "string") {
+            const val = self.get(prop);
+            if (val !== void 0) return val;
+          }
+          return target[prop];
+        },
+        set(target, prop, value) {
+          target[prop] = value;
+          return true;
+        }
+      });
+    } catch (e) {
+    }
+  }
+  mergeDefaults(env) {
+    let changed = false;
+    for (const [key, defaultValue] of Object.entries(env)) {
+      const isOverridden = key in this.overrides;
+      const currentValue = isOverridden ? this.overrides[key] : defaultValue;
+      const isSecret = this.secretPattern.test(key);
+      const existing = this.variables.get(key);
+      if (!existing) {
+        this.variables.set(key, {
+          key,
+          value: currentValue,
+          defaultValue,
+          isOverridden,
+          isSecret
+        });
+        changed = true;
+      } else {
+        if (existing.defaultValue !== defaultValue) {
+          existing.defaultValue = defaultValue;
+          if (!existing.isOverridden) {
+            existing.value = defaultValue;
+          }
+          changed = true;
+        }
+      }
+    }
+    if (changed) {
+      this.notifyStoreChanged();
+    }
+  }
+  get(key, fallback) {
+    if (key in this.overrides) {
+      return this.overrides[key];
+    }
+    const item = this.variables.get(key);
+    if (item) return item.value;
+    return fallback;
+  }
+  getAll() {
+    const result = {};
+    this.variables.forEach((varObj, key) => {
+      result[key] = { ...varObj };
+    });
+    return result;
+  }
+  getOverrides() {
+    return { ...this.overrides };
+  }
+  setOverride(key, value) {
+    const trimmedKey = key.trim();
+    if (!trimmedKey) return;
+    this.overrides[trimmedKey] = value;
+    this.saveOverridesToStorage();
+    let item = this.variables.get(trimmedKey);
+    if (!item) {
+      item = {
+        key: trimmedKey,
+        value,
+        defaultValue: "",
+        isOverridden: true,
+        isSecret: this.secretPattern.test(trimmedKey)
+      };
+      this.variables.set(trimmedKey, item);
+    } else {
+      item.value = value;
+      item.isOverridden = true;
+    }
+    this.emitEnvChange(trimmedKey, value, true);
+    this.notifyStoreChanged();
+  }
+  removeOverride(key) {
+    if (key in this.overrides) {
+      delete this.overrides[key];
+      this.saveOverridesToStorage();
+      const item = this.variables.get(key);
+      if (item) {
+        item.value = item.defaultValue;
+        item.isOverridden = false;
+        this.emitEnvChange(key, item.value, false);
+      }
+      this.notifyStoreChanged();
+    }
+  }
+  resetAllOverrides() {
+    const keys = Object.keys(this.overrides);
+    this.overrides = {};
+    this.saveOverridesToStorage();
+    this.presetManager.setActivePreset(null);
+    keys.forEach((key) => {
+      const item = this.variables.get(key);
+      if (item) {
+        item.value = item.defaultValue;
+        item.isOverridden = false;
+        this.emitEnvChange(key, item.value, false);
+      }
+    });
+    this.notifyStoreChanged();
+  }
+  applyPreset(presetId) {
+    const preset = this.presetManager.setActivePreset(presetId);
+    this.overrides = preset ? { ...preset.overrides } : {};
+    this.saveOverridesToStorage();
+    this.variables.forEach((item, key) => {
+      if (key in this.overrides) {
+        item.value = this.overrides[key];
+        item.isOverridden = true;
+      } else {
+        item.value = item.defaultValue;
+        item.isOverridden = false;
+      }
+      this.emitEnvChange(key, item.value, item.isOverridden);
+    });
+    if (preset) {
+      for (const [key, value] of Object.entries(preset.overrides)) {
+        if (!this.variables.has(key)) {
+          this.variables.set(key, {
+            key,
+            value,
+            defaultValue: "",
+            isOverridden: true,
+            isSecret: this.secretPattern.test(key)
+          });
+          this.emitEnvChange(key, value, true);
+        }
+      }
+    }
+    this.notifyStoreChanged();
+  }
+  subscribeEnvChange(listener) {
+    this.envChangeListeners.add(listener);
+    return () => this.envChangeListeners.delete(listener);
+  }
+  subscribeStoreChange(listener) {
+    this.storeChangeListeners.add(listener);
+    return () => this.storeChangeListeners.delete(listener);
+  }
+  emitEnvChange(key, value, isOverridden) {
+    this.envChangeListeners.forEach((fn) => fn(key, value, isOverridden));
+    if (typeof window !== "undefined") {
+      window.dispatchEvent(
+        new CustomEvent("lamba:env-change", {
+          detail: { key, value, isOverridden }
+        })
+      );
+    }
+  }
+  notifyStoreChanged() {
+    const varsObj = this.getAll();
+    const presets = this.presetManager.getPresets();
+    const activePresetId = this.presetManager.getActivePresetId();
+    this.storeChangeListeners.forEach((fn) => fn(varsObj, presets, activePresetId));
+  }
+};
+
+// src/core/network-interceptor.ts
+var NetworkInterceptor = class {
+  constructor(store) {
+    this.originalFetch = null;
+    this.originalXHRPost = null;
+    this.isIntercepting = false;
+    this.store = store;
+  }
+  enable() {
+    if (typeof window === "undefined" || this.isIntercepting) return;
+    this.patchFetch();
+    this.patchXHR();
+    this.isIntercepting = true;
+  }
+  disable() {
+    if (typeof window === "undefined" || !this.isIntercepting) return;
+    if (this.originalFetch) {
+      window.fetch = this.originalFetch;
+      this.originalFetch = null;
+    }
+    if (this.originalXHRPost) {
+      XMLHttpRequest.prototype.open = this.originalXHRPost;
+      this.originalXHRPost = null;
+    }
+    this.isIntercepting = false;
+  }
+  /**
+   * Rewrite a given URL by checking if any default env variable URL value matches
+   * and replacing it with the active overridden value.
+   */
+  rewriteUrl(url) {
+    if (typeof url !== "string") return url;
+    const allVars = this.store.getAll();
+    let resultUrl = url;
+    for (const varObj of Object.values(allVars)) {
+      if (varObj.isOverridden && varObj.defaultValue && varObj.value) {
+        const defaultBase = varObj.defaultValue.replace(/\/+$/, "");
+        const overrideBase = varObj.value.replace(/\/+$/, "");
+        if (defaultBase && resultUrl.includes(defaultBase)) {
+          resultUrl = resultUrl.replace(defaultBase, overrideBase);
+        }
+      }
+    }
+    return resultUrl;
+  }
+  patchFetch() {
+    if (!window.fetch) return;
+    this.originalFetch = window.fetch;
+    const self = this;
+    window.fetch = function(input, init) {
+      let finalInput = input;
+      if (typeof input === "string") {
+        finalInput = self.rewriteUrl(input);
+      } else if (input instanceof URL) {
+        const rewritten = self.rewriteUrl(input.toString());
+        finalInput = new URL(rewritten);
+      } else if (input instanceof Request) {
+        const rewrittenUrl = self.rewriteUrl(input.url);
+        if (rewrittenUrl !== input.url) {
+          finalInput = new Request(rewrittenUrl, input);
+        }
+      }
+      return self.originalFetch.call(this, finalInput, init);
+    };
+  }
+  patchXHR() {
+    if (!window.XMLHttpRequest) return;
+    this.originalXHRPost = XMLHttpRequest.prototype.open;
+    const self = this;
+    XMLHttpRequest.prototype.open = function(method, url, async = true, username, password) {
+      const stringUrl = typeof url === "string" ? url : url.toString();
+      const rewrittenUrl = self.rewriteUrl(stringUrl);
+      return self.originalXHRPost.call(
+        this,
+        method,
+        rewrittenUrl,
+        async,
+        username ?? null,
+        password ?? null
+      );
+    };
+  }
+};
+
+// src/ui/styles.ts
+var LAMBA_STYLES = `
+:host {
+  --lamba-bg-main: #0f172a;
+  --lamba-bg-card: #1e293b;
+  --lamba-bg-hover: #334155;
+  --lamba-border: rgba(255, 255, 255, 0.1);
+  --lamba-text-primary: #f8fafc;
+  --lamba-text-secondary: #94a3b8;
+  --lamba-primary: #6366f1;
+  --lamba-primary-hover: #4f46e5;
+  --lamba-accent: #06b6d4;
+  --lamba-success: #10b981;
+  --lamba-danger: #ef4444;
+  --lamba-warning: #f59e0b;
+  --lamba-font: system-ui, -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+  --lamba-shadow: 0 20px 25px -5px rgba(0, 0, 0, 0.5), 0 8px 10px -6px rgba(0, 0, 0, 0.4);
+
+  font-family: var(--lamba-font);
+  font-size: 14px;
+  line-height: 1.5;
+  color: var(--lamba-text-primary);
+  box-sizing: border-box;
+  z-index: 999999;
+}
+
+*, *:before, *:after {
+  box-sizing: border-box;
+}
+
+/* Floating Launcher Button */
+.lamba-launcher {
+  position: fixed;
+  z-index: 999999;
+  width: 52px;
+  height: 52px;
+  border-radius: 50%;
+  background: linear-gradient(135deg, #6366f1 0%, #4f46e5 100%);
+  color: #ffffff;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  cursor: pointer;
+  box-shadow: 0 10px 15px -3px rgba(99, 102, 241, 0.4), 0 4px 6px -4px rgba(99, 102, 241, 0.2);
+  border: 1px solid rgba(255, 255, 255, 0.2);
+  transition: transform 0.2s ease, box-shadow 0.2s ease;
+  user-select: none;
+}
+
+.lamba-launcher:hover {
+  transform: scale(1.08);
+  box-shadow: 0 14px 20px -3px rgba(99, 102, 241, 0.6), 0 6px 8px -4px rgba(99, 102, 241, 0.3);
+}
+
+.lamba-launcher:active {
+  transform: scale(0.95);
+}
+
+.lamba-launcher-bottom-right { bottom: 24px; right: 24px; }
+.lamba-launcher-bottom-left  { bottom: 24px; left: 24px; }
+.lamba-launcher-top-right    { top: 24px; right: 24px; }
+.lamba-launcher-top-left     { top: 24px; left: 24px; }
+
+.lamba-badge {
+  position: absolute;
+  top: -4px;
+  right: -4px;
+  background: var(--lamba-accent);
+  color: #000;
+  font-size: 11px;
+  font-weight: 700;
+  min-width: 20px;
+  height: 20px;
+  border-radius: 10px;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  padding: 0 5px;
+  border: 2px solid var(--lamba-bg-main);
+  box-shadow: 0 2px 4px rgba(0,0,0,0.2);
+  animation: pulse-scale 2s infinite;
+}
+
+@keyframes pulse-scale {
+  0%, 100% { transform: scale(1); }
+  50% { transform: scale(1.15); }
+}
+
+/* Modal Overlay */
+.lamba-overlay {
+  position: fixed;
+  top: 0;
+  left: 0;
+  width: 100vw;
+  height: 100vh;
+  background: rgba(15, 23, 42, 0.7);
+  backdrop-filter: blur(8px);
+  z-index: 999998;
+  opacity: 0;
+  visibility: hidden;
+  transition: opacity 0.25s ease, visibility 0.25s ease;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  padding: 20px;
+}
+
+.lamba-overlay.active {
+  opacity: 1;
+  visibility: visible;
+}
+
+/* Main Modal Panel */
+.lamba-modal {
+  width: 100%;
+  max-width: 820px;
+  max-height: 85vh;
+  background: var(--lamba-bg-main);
+  border: 1px solid var(--lamba-border);
+  border-radius: 16px;
+  box-shadow: var(--lamba-shadow);
+  display: flex;
+  flex-direction: column;
+  overflow: hidden;
+  transform: translateY(20px) scale(0.96);
+  transition: transform 0.25s cubic-bezier(0.16, 1, 0.3, 1);
+}
+
+.lamba-overlay.active .lamba-modal {
+  transform: translateY(0) scale(1);
+}
+
+/* Header */
+.lamba-header {
+  padding: 20px 24px;
+  border-bottom: 1px solid var(--lamba-border);
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  background: rgba(30, 41, 59, 0.4);
+}
+
+.lamba-brand {
+  display: flex;
+  align-items: center;
+  gap: 12px;
+}
+
+.lamba-logo {
+  font-size: 18px;
+  font-weight: 800;
+  letter-spacing: -0.5px;
+  background: linear-gradient(135deg, #a5b4fc 0%, #6366f1 100%);
+  -webkit-background-clip: text;
+  -webkit-text-fill-color: transparent;
+  display: flex;
+  align-items: center;
+  gap: 8px;
+}
+
+.lamba-tag {
+  background: rgba(99, 102, 241, 0.15);
+  color: #a5b4fc;
+  font-size: 11px;
+  padding: 2px 8px;
+  border-radius: 6px;
+  font-weight: 600;
+  border: 1px solid rgba(99, 102, 241, 0.3);
+}
+
+.lamba-close-btn {
+  background: transparent;
+  border: none;
+  color: var(--lamba-text-secondary);
+  cursor: pointer;
+  padding: 6px;
+  border-radius: 8px;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  transition: background 0.15s ease, color 0.15s ease;
+}
+
+.lamba-close-btn:hover {
+  background: var(--lamba-bg-hover);
+  color: var(--lamba-text-primary);
+}
+
+/* Controls Bar (Search & Filters) */
+.lamba-controls {
+  padding: 16px 24px;
+  border-bottom: 1px solid var(--lamba-border);
+  display: flex;
+  gap: 12px;
+  align-items: center;
+  flex-wrap: wrap;
+  background: var(--lamba-bg-main);
+}
+
+.lamba-search-box {
+  flex: 1;
+  min-width: 220px;
+  position: relative;
+}
+
+.lamba-search-input {
+  width: 100%;
+  padding: 10px 14px 10px 38px;
+  background: var(--lamba-bg-card);
+  border: 1px solid var(--lamba-border);
+  border-radius: 8px;
+  color: var(--lamba-text-primary);
+  font-size: 13px;
+  outline: none;
+  transition: border-color 0.15s ease;
+}
+
+.lamba-search-input:focus {
+  border-color: var(--lamba-primary);
+}
+
+.lamba-search-icon {
+  position: absolute;
+  left: 12px;
+  top: 50%;
+  transform: translateY(-50%);
+  color: var(--lamba-text-secondary);
+  pointer-events: none;
+}
+
+.lamba-tabs {
+  display: flex;
+  gap: 4px;
+  background: var(--lamba-bg-card);
+  padding: 4px;
+  border-radius: 8px;
+  border: 1px solid var(--lamba-border);
+}
+
+.lamba-tab {
+  background: transparent;
+  border: none;
+  color: var(--lamba-text-secondary);
+  padding: 6px 12px;
+  border-radius: 6px;
+  font-size: 12px;
+  font-weight: 600;
+  cursor: pointer;
+  transition: all 0.15s ease;
+}
+
+.lamba-tab.active {
+  background: var(--lamba-primary);
+  color: #ffffff;
+}
+
+/* Preset Bar */
+.lamba-presets-bar {
+  padding: 12px 24px;
+  background: rgba(30, 41, 59, 0.3);
+  border-bottom: 1px solid var(--lamba-border);
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 12px;
+}
+
+.lamba-preset-selector {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  font-size: 13px;
+}
+
+.lamba-select {
+  background: var(--lamba-bg-card);
+  color: var(--lamba-text-primary);
+  border: 1px solid var(--lamba-border);
+  padding: 6px 12px;
+  border-radius: 6px;
+  outline: none;
+  font-size: 13px;
+  cursor: pointer;
+}
+
+/* List Content */
+.lamba-content {
+  flex: 1;
+  overflow-y: auto;
+  padding: 16px 24px;
+  display: flex;
+  flex-direction: column;
+  gap: 12px;
+}
+
+.lamba-content::-webkit-scrollbar {
+  width: 6px;
+}
+
+.lamba-content::-webkit-scrollbar-track {
+  background: transparent;
+}
+
+.lamba-content::-webkit-scrollbar-thumb {
+  background: var(--lamba-bg-hover);
+  border-radius: 3px;
+}
+
+/* Variable Row Card */
+.lamba-var-card {
+  background: var(--lamba-bg-card);
+  border: 1px solid var(--lamba-border);
+  border-radius: 10px;
+  padding: 14px 16px;
+  display: flex;
+  flex-direction: column;
+  gap: 8px;
+  transition: border-color 0.15s ease;
+}
+
+.lamba-var-card.is-overridden {
+  border-color: rgba(99, 102, 241, 0.5);
+  background: linear-gradient(180deg, var(--lamba-bg-card) 0%, rgba(99, 102, 241, 0.05) 100%);
+}
+
+.lamba-var-meta {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+}
+
+.lamba-var-key {
+  font-weight: 700;
+  font-family: monospace;
+  color: #a5b4fc;
+  font-size: 13px;
+  display: flex;
+  align-items: center;
+  gap: 8px;
+}
+
+.lamba-modified-pill {
+  font-size: 10px;
+  font-weight: 700;
+  background: rgba(16, 185, 129, 0.2);
+  color: #34d399;
+  padding: 2px 6px;
+  border-radius: 4px;
+  border: 1px solid rgba(16, 185, 129, 0.4);
+}
+
+.lamba-var-actions {
+  display: flex;
+  align-items: center;
+  gap: 6px;
+}
+
+.lamba-icon-btn {
+  background: transparent;
+  border: none;
+  color: var(--lamba-text-secondary);
+  cursor: pointer;
+  padding: 4px;
+  border-radius: 4px;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  transition: background 0.15s ease, color 0.15s ease;
+}
+
+.lamba-icon-btn:hover {
+  background: var(--lamba-bg-hover);
+  color: var(--lamba-text-primary);
+}
+
+.lamba-var-input-group {
+  display: flex;
+  gap: 8px;
+}
+
+.lamba-input {
+  flex: 1;
+  background: var(--lamba-bg-main);
+  border: 1px solid var(--lamba-border);
+  color: var(--lamba-text-primary);
+  padding: 8px 12px;
+  border-radius: 6px;
+  font-family: monospace;
+  font-size: 13px;
+  outline: none;
+}
+
+.lamba-input:focus {
+  border-color: var(--lamba-primary);
+}
+
+.lamba-diff {
+  font-size: 11px;
+  color: var(--lamba-text-secondary);
+  font-family: monospace;
+  padding-left: 2px;
+}
+
+.lamba-diff-val {
+  color: var(--lamba-warning);
+}
+
+/* Empty State */
+.lamba-empty {
+  padding: 40px 20px;
+  text-align: center;
+  color: var(--lamba-text-secondary);
+}
+
+/* Footer Actions Bar */
+.lamba-footer {
+  padding: 16px 24px;
+  border-top: 1px solid var(--lamba-border);
+  background: rgba(30, 41, 59, 0.4);
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 12px;
+  flex-wrap: wrap;
+}
+
+.lamba-btn {
+  background: var(--lamba-bg-card);
+  color: var(--lamba-text-primary);
+  border: 1px solid var(--lamba-border);
+  padding: 8px 14px;
+  border-radius: 8px;
+  font-size: 12px;
+  font-weight: 600;
+  cursor: pointer;
+  display: flex;
+  align-items: center;
+  gap: 6px;
+  transition: all 0.15s ease;
+}
+
+.lamba-btn:hover {
+  background: var(--lamba-bg-hover);
+}
+
+.lamba-btn-primary {
+  background: var(--lamba-primary);
+  border-color: var(--lamba-primary);
+  color: #ffffff;
+}
+
+.lamba-btn-primary:hover {
+  background: var(--lamba-primary-hover);
+}
+
+.lamba-btn-danger {
+  background: rgba(239, 68, 68, 0.15);
+  color: #fca5a5;
+  border-color: rgba(239, 68, 68, 0.3);
+}
+
+.lamba-btn-danger:hover {
+  background: rgba(239, 68, 68, 0.3);
+}
+`;
+
+// src/ui/shadow-dom.ts
+function createShadowHost() {
+  if (typeof document === "undefined") {
+    throw new Error("[lamba] Document object not available.");
+  }
+  let host = document.getElementById("lamba-root");
+  if (!host) {
+    host = document.createElement("lamba-widget");
+    host.id = "lamba-root";
+    document.body.appendChild(host);
+  }
+  let shadowRoot = host.shadowRoot;
+  if (!shadowRoot) {
+    shadowRoot = host.attachShadow({ mode: "open" });
+    const styleEl = document.createElement("style");
+    styleEl.textContent = LAMBA_STYLES;
+    shadowRoot.appendChild(styleEl);
+  }
+  return { host, shadowRoot };
+}
+
+// src/ui/launcher.ts
+var LauncherUI = class {
+  constructor(container, position = "bottom-right", onClick) {
+    this.onClickCallback = onClick;
+    this.element = document.createElement("div");
+    this.element.className = `lamba-launcher lamba-launcher-${position}`;
+    this.element.title = "Open lamba Environment Controls";
+    this.element.innerHTML = `
+      <svg width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+        <path d="M12.22 2h-.44a2 2 0 0 0-2 2v.18a2 2 0 0 1-1 1.73l-.43.25a2 2 0 0 1-2 0l-.15-.08a2 2 0 0 0-2.73.73l-.22.38a2 2 0 0 0 .73 2.73l.15.1a2 2 0 0 1 1 1.72v.51a2 2 0 0 1-1 1.74l-.15.09a2 2 0 0 0-.73 2.73l.22.38a2 2 0 0 0 2.73.73l.15-.08a2 2 0 0 1 2 0l.43.25a2 2 0 0 1 1 1.73V20a2 2 0 0 0 2 2h.44a2 2 0 0 0 2-2v-.18a2 2 0 0 1 1-1.73l.43-.25a2 2 0 0 1 2 0l.15.08a2 2 0 0 0 2.73-.73l.22-.39a2 2 0 0 0-.73-2.73l-.15-.08a2 2 0 0 1-1-1.74v-.5a2 2 0 0 1 1-1.74l.15-.09a2 2 0 0 0 .73-2.73l-.22-.38a2 2 0 0 0-2.73-.73l-.15.08a2 2 0 0 1-2 0l-.43-.25a2 2 0 0 1-1-1.73V4a2 2 0 0 0-2-2z"/>
+        <circle cx="12" cy="12" r="3"/>
+      </svg>
+    `;
+    this.badgeElement = document.createElement("div");
+    this.badgeElement.className = "lamba-badge";
+    this.badgeElement.style.display = "none";
+    this.element.appendChild(this.badgeElement);
+    this.element.addEventListener("click", () => this.onClickCallback());
+    container.appendChild(this.element);
+  }
+  updateBadgeCount(count) {
+    if (count > 0) {
+      this.badgeElement.textContent = String(count);
+      this.badgeElement.style.display = "flex";
+    } else {
+      this.badgeElement.style.display = "none";
+    }
+  }
+  setVisible(visible) {
+    this.element.style.display = visible ? "flex" : "none";
+  }
+};
+
+// src/ui/modal.ts
+var ModalUI = class {
+  constructor(container, store, onClose) {
+    this.activeTab = "all";
+    this.searchQuery = "";
+    this.secretVisibilityMap = /* @__PURE__ */ new Map();
+    this.isOpen = false;
+    this.store = store;
+    this.overlay = document.createElement("div");
+    this.overlay.className = "lamba-overlay";
+    this.modal = document.createElement("div");
+    this.modal.className = "lamba-modal";
+    const header = document.createElement("div");
+    header.className = "lamba-header";
+    header.innerHTML = `
+      <div class="lamba-brand">
+        <div class="lamba-logo">
+          <svg width="20" height="20" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.5">
+            <path d="M12 2L2 7l10 5 10-5-10-5zM2 17l10 5 10-5M2 12l10 5 10-5"/>
+          </svg>
+          lamba
+        </div>
+        <span class="lamba-tag">Dev Environment Override</span>
+      </div>
+      <button class="lamba-close-btn" title="Close modal">
+        <svg width="20" height="20" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
+          <line x1="18" y1="6" x2="6" y2="18"></line>
+          <line x1="6" y1="6" x2="18" y2="18"></line>
+        </svg>
+      </button>
+    `;
+    header.querySelector(".lamba-close-btn")?.addEventListener("click", () => {
+      this.close();
+      onClose();
+    });
+    const controls = document.createElement("div");
+    controls.className = "lamba-controls";
+    const searchBox = document.createElement("div");
+    searchBox.className = "lamba-search-box";
+    searchBox.innerHTML = `
+      <svg class="lamba-search-icon" width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
+        <circle cx="11" cy="11" r="8"></circle>
+        <line x1="21" y1="21" x2="16.65" y2="16.65"></line>
+      </svg>
+      <input type="text" class="lamba-search-input" placeholder="Search environment keys or values..." />
+    `;
+    this.searchInput = searchBox.querySelector(".lamba-search-input");
+    this.searchInput.addEventListener("input", (e) => {
+      this.searchQuery = e.target.value.toLowerCase();
+      this.render();
+    });
+    const tabs = document.createElement("div");
+    tabs.className = "lamba-tabs";
+    tabs.innerHTML = `
+      <button class="lamba-tab active" data-tab="all">All</button>
+      <button class="lamba-tab" data-tab="overridden">Modified</button>
+      <button class="lamba-tab" data-tab="secrets">Secrets</button>
+    `;
+    this.tabAllBtn = tabs.querySelector('[data-tab="all"]');
+    this.tabOverriddenBtn = tabs.querySelector('[data-tab="overridden"]');
+    this.tabSecretsBtn = tabs.querySelector('[data-tab="secrets"]');
+    tabs.querySelectorAll(".lamba-tab").forEach((btn) => {
+      btn.addEventListener("click", (e) => {
+        tabs.querySelectorAll(".lamba-tab").forEach((t) => t.classList.remove("active"));
+        const target = e.currentTarget;
+        target.classList.add("active");
+        this.activeTab = target.getAttribute("data-tab");
+        this.render();
+      });
+    });
+    controls.appendChild(searchBox);
+    controls.appendChild(tabs);
+    const presetsBar = document.createElement("div");
+    presetsBar.className = "lamba-presets-bar";
+    presetsBar.innerHTML = `
+      <div class="lamba-preset-selector">
+        <span style="color: var(--lamba-text-secondary); font-weight: 600;">Preset Profile:</span>
+        <select class="lamba-select lamba-preset-dropdown">
+          <option value="">Default (Current Overrides)</option>
+        </select>
+      </div>
+      <button class="lamba-btn lamba-save-preset-btn">
+        <svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
+          <path d="M19 21H5a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h11l5 5v11a2 2 0 0 1-2 2z"></path>
+          <polyline points="17 21 17 13 7 13 7 21"></polyline>
+          <polyline points="7 3 7 8 15 8"></polyline>
+        </svg>
+        Save as Preset
+      </button>
+    `;
+    this.presetSelect = presetsBar.querySelector(".lamba-preset-dropdown");
+    this.presetSelect.addEventListener("change", () => {
+      const selectedId = this.presetSelect.value || null;
+      this.store.applyPreset(selectedId);
+    });
+    this.savePresetBtn = presetsBar.querySelector(".lamba-save-preset-btn");
+    this.savePresetBtn.addEventListener("click", () => {
+      const name = prompt("Enter a name for this Environment Preset Profile:", "Staging Environment");
+      if (name) {
+        const overrides = this.store.getOverrides();
+        this.store.presetManager.createPreset(name, overrides);
+        this.updatePresetDropdown();
+      }
+    });
+    this.contentList = document.createElement("div");
+    this.contentList.className = "lamba-content";
+    const footer = document.createElement("div");
+    footer.className = "lamba-footer";
+    footer.innerHTML = `
+      <div style="display: flex; gap: 8px;">
+        <button class="lamba-btn lamba-add-var-btn">
+          <svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
+            <line x1="12" y1="5" x2="12" y2="19"></line>
+            <line x1="5" y1="12" x2="19" y2="12"></line>
+          </svg>
+          Add Variable
+        </button>
+        <button class="lamba-btn lamba-import-btn">Import .env</button>
+        <button class="lamba-btn lamba-export-btn">Export .env</button>
+      </div>
+      <div style="display: flex; gap: 8px;">
+        <button class="lamba-btn lamba-btn-danger lamba-reset-all-btn">Reset All</button>
+        <button class="lamba-btn lamba-btn-primary lamba-reload-btn">Reload Page</button>
+      </div>
+    `;
+    footer.querySelector(".lamba-add-var-btn")?.addEventListener("click", () => {
+      const key = prompt("Enter new environment variable key name (e.g. VITE_API_URL):");
+      if (key) {
+        const value = prompt(`Enter value for ${key}:`) || "";
+        this.store.setOverride(key, value);
+      }
+    });
+    footer.querySelector(".lamba-import-btn")?.addEventListener("click", () => {
+      const input = document.createElement("input");
+      input.type = "file";
+      input.accept = ".env,.txt";
+      input.onchange = (e) => {
+        const file = e.target.files[0];
+        if (file) {
+          const reader = new FileReader();
+          reader.onload = (event) => {
+            const content = event.target?.result;
+            if (content) {
+              const parsed = parseEnvString(content);
+              for (const [k, v] of Object.entries(parsed)) {
+                this.store.setOverride(k, v);
+              }
+            }
+          };
+          reader.readAsText(file);
+        }
+      };
+      input.click();
+    });
+    footer.querySelector(".lamba-export-btn")?.addEventListener("click", () => {
+      const allVars = this.store.getAll();
+      const exportObj = {};
+      for (const [k, v] of Object.entries(allVars)) {
+        exportObj[k] = v.value;
+      }
+      const envText = stringifyEnv(exportObj);
+      const blob = new Blob([envText], { type: "text/plain" });
+      const url = URL.createObjectURL(blob);
+      const a = document.createElement("a");
+      a.href = url;
+      a.download = ".env";
+      a.click();
+      URL.revokeObjectURL(url);
+    });
+    footer.querySelector(".lamba-reset-all-btn")?.addEventListener("click", () => {
+      if (confirm("Are you sure you want to reset all overridden environment variables?")) {
+        this.store.resetAllOverrides();
+      }
+    });
+    footer.querySelector(".lamba-reload-btn")?.addEventListener("click", () => {
+      window.location.reload();
+    });
+    this.modal.appendChild(header);
+    this.modal.appendChild(controls);
+    this.modal.appendChild(presetsBar);
+    this.modal.appendChild(this.contentList);
+    this.modal.appendChild(footer);
+    this.overlay.appendChild(this.modal);
+    this.overlay.addEventListener("click", (e) => {
+      if (e.target === this.overlay) {
+        this.close();
+        onClose();
+      }
+    });
+    container.appendChild(this.overlay);
+    this.store.subscribeStoreChange(() => {
+      if (this.isOpen) {
+        this.updatePresetDropdown();
+        this.render();
+      }
+    });
+  }
+  open() {
+    this.isOpen = true;
+    this.updatePresetDropdown();
+    this.render();
+    this.overlay.classList.add("active");
+  }
+  close() {
+    this.isOpen = false;
+    this.overlay.classList.remove("active");
+  }
+  toggle() {
+    if (this.isOpen) {
+      this.close();
+    } else {
+      this.open();
+    }
+  }
+  updatePresetDropdown() {
+    const presets = this.store.presetManager.getPresets();
+    const activeId = this.store.presetManager.getActivePresetId();
+    this.presetSelect.innerHTML = `<option value="">Default (Custom Overrides)</option>`;
+    presets.forEach((p) => {
+      const opt = document.createElement("option");
+      opt.value = p.id;
+      opt.textContent = p.name;
+      if (p.id === activeId) opt.selected = true;
+      this.presetSelect.appendChild(opt);
+    });
+  }
+  render() {
+    const allVarsMap = this.store.getAll();
+    let varList = Object.values(allVarsMap);
+    if (this.activeTab === "overridden") {
+      varList = varList.filter((v) => v.isOverridden);
+    } else if (this.activeTab === "secrets") {
+      varList = varList.filter((v) => v.isSecret);
+    }
+    if (this.searchQuery) {
+      varList = varList.filter(
+        (v) => v.key.toLowerCase().includes(this.searchQuery) || v.value.toLowerCase().includes(this.searchQuery)
+      );
+    }
+    varList.sort((a, b) => {
+      if (a.isOverridden !== b.isOverridden) {
+        return a.isOverridden ? -1 : 1;
+      }
+      return a.key.localeCompare(b.key);
+    });
+    this.contentList.innerHTML = "";
+    if (varList.length === 0) {
+      const empty = document.createElement("div");
+      empty.className = "lamba-empty";
+      empty.textContent = this.searchQuery || this.activeTab !== "all" ? "No environment variables match your current filter." : 'No environment variables found or registered. Click "+ Add Variable" or "Import .env" to get started.';
+      this.contentList.appendChild(empty);
+      return;
+    }
+    varList.forEach((varItem) => {
+      const card = this.createVarCard(varItem);
+      this.contentList.appendChild(card);
+    });
+  }
+  createVarCard(varItem) {
+    const card = document.createElement("div");
+    card.className = `lamba-var-card ${varItem.isOverridden ? "is-overridden" : ""}`;
+    const isVisible = this.secretVisibilityMap.get(varItem.key) ?? !varItem.isSecret;
+    card.innerHTML = `
+      <div class="lamba-var-meta">
+        <div class="lamba-var-key">
+          ${varItem.key}
+          ${varItem.isOverridden ? '<span class="lamba-modified-pill">MODIFIED</span>' : ""}
+          ${varItem.isSecret ? '<span style="font-size:10px; color:var(--lamba-warning); font-weight:600;">SECRET</span>' : ""}
+        </div>
+        <div class="lamba-var-actions">
+          ${varItem.isSecret ? `<button class="lamba-icon-btn toggle-secret-btn" title="${isVisible ? "Hide secret" : "Show secret"}">
+                  <svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
+                    ${isVisible ? '<path d="M1 12s4-8 11-8 11 8 11 8-4 8-11 8-11-8-11-8z"/><circle cx="12" cy="12" r="3"/>' : '<path d="M17.94 17.94A10.07 10.07 0 0 1 12 20c-7 0-11-8-11-8a18.45 18.45 0 0 1 5.06-5.94M9.9 4.24A9.12 9.12 0 0 1 12 4c7 0 11 8 11 8a18.5 18.5 0 0 1-2.16 3.19m-6.72-1.07a3 3 0 1 1-4.24-4.24"/><line x1="1" y1="1" x2="23" y2="23"/>'}
+                  </svg>
+                </button>` : ""}
+          ${varItem.isOverridden ? `<button class="lamba-icon-btn reset-var-btn" title="Reset to default">
+                  <svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
+                    <path d="M3 12a9 9 0 1 0 9-9 9.75 9.75 0 0 0-6.74 2.74L3 8"/>
+                    <path d="M3 3v5h5"/>
+                  </svg>
+                </button>` : ""}
+        </div>
+      </div>
+      <div class="lamba-var-input-group">
+        <input 
+          type="${isVisible ? "text" : "password"}" 
+          class="lamba-input var-input" 
+          value="${this.escapeHtml(varItem.value)}" 
+          placeholder="Value..."
+        />
+      </div>
+      ${varItem.isOverridden && varItem.defaultValue ? `<div class="lamba-diff">Original default: <span class="lamba-diff-val">${this.escapeHtml(
+      varItem.defaultValue
+    )}</span></div>` : ""}
+    `;
+    const inputEl = card.querySelector(".var-input");
+    inputEl.addEventListener("change", () => {
+      this.store.setOverride(varItem.key, inputEl.value);
+    });
+    card.querySelector(".toggle-secret-btn")?.addEventListener("click", () => {
+      this.secretVisibilityMap.set(varItem.key, !isVisible);
+      this.render();
+    });
+    card.querySelector(".reset-var-btn")?.addEventListener("click", () => {
+      this.store.removeOverride(varItem.key);
+    });
+    return card;
+  }
+  escapeHtml(str) {
+    return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#039;");
+  }
+};
+
+// src/index.ts
+var LambaManager = class {
+  constructor() {
+    this.store = null;
+    this.launcher = null;
+    this.modal = null;
+    this.networkInterceptor = null;
+    this.options = {};
+    this.isInitialized = false;
+    const self = this;
+    this.env = new Proxy({}, {
+      get(_target, prop) {
+        if (typeof prop === "string") {
+          return self.get(prop);
+        }
+        return void 0;
+      },
+      set(_target, prop, value) {
+        if (typeof prop === "string") {
+          self.set(prop, String(value));
+          return true;
+        }
+        return false;
+      }
+    });
+  }
+  /**
+   * Wraps any environment object (such as `import.meta.env` or `process.env`)
+   * in a dynamic proxy that implicitly resolves live overrides from lamba.
+   */
+  wrap(targetEnv) {
+    const self = this;
+    return new Proxy(targetEnv, {
+      get(target, prop) {
+        if (typeof prop === "string") {
+          const overrideVal = self.get(prop);
+          if (overrideVal !== void 0 && overrideVal !== "") {
+            return overrideVal;
+          }
+        }
+        return Reflect.get(target, prop);
+      }
+    });
+  }
+  /**
+   * Initializes lamba with custom options and mounts the floating UI.
+   */
+  init(options = {}) {
+    if (typeof window === "undefined") return this;
+    if (this.isInitialized) return this;
+    this.options = {
+      enabled: true,
+      position: "bottom-right",
+      autoFetchEnvFile: false,
+      interceptNetworkRequests: true,
+      ...options
+    };
+    if (this.options.enabled === false) return this;
+    this.store = new EnvStore(this.options);
+    if (this.options.interceptNetworkRequests !== false) {
+      this.networkInterceptor = new NetworkInterceptor(this.store);
+      this.networkInterceptor.enable();
+    }
+    const mountUI = () => {
+      if (this.launcher || !this.store) return;
+      const { shadowRoot } = createShadowHost();
+      this.modal = new ModalUI(shadowRoot, this.store, () => {
+      });
+      this.launcher = new LauncherUI(shadowRoot, this.options.position, () => {
+        this.modal?.toggle();
+      });
+      const initialOverridesCount = Object.keys(this.store.getOverrides()).length;
+      this.launcher.updateBadgeCount(initialOverridesCount);
+      this.store.subscribeStoreChange(() => {
+        const count = Object.keys(this.store.getOverrides()).length;
+        this.launcher?.updateBadgeCount(count);
+      });
+    };
+    if (document.readyState === "loading") {
+      document.addEventListener("DOMContentLoaded", mountUI);
+    } else {
+      mountUI();
+    }
+    this.isInitialized = true;
+    return this;
+  }
+  /**
+   * Gets the active value of an environment variable (returns overridden value if active, otherwise default).
+   */
+  get(key, fallback) {
+    if (!this.store) {
+      this.init();
+    }
+    return this.store?.get(key, fallback) ?? fallback ?? "";
+  }
+  /**
+   * Overrides an environment variable live at runtime.
+   */
+  set(key, value) {
+    if (!this.store) this.init();
+    this.store?.setOverride(key, value);
+  }
+  /**
+   * Removes an override for a specific environment variable key.
+   */
+  remove(key) {
+    this.store?.removeOverride(key);
+  }
+  /**
+   * Resets all environment variable overrides.
+   */
+  reset() {
+    this.store?.resetAllOverrides();
+  }
+  /**
+   * Subscribes to environment variable changes.
+   */
+  onChange(listener) {
+    if (!this.store) this.init();
+    return this.store?.subscribeEnvChange(listener) ?? (() => {
+    });
+  }
+  /**
+   * Programmatically opens the lamba floating modal.
+   */
+  open() {
+    this.modal?.open();
+  }
+  /**
+   * Programmatically closes the lamba floating modal.
+   */
+  close() {
+    this.modal?.close();
+  }
+  /**
+   * Programmatically toggles the lamba floating modal.
+   */
+  toggle() {
+    this.modal?.toggle();
+  }
+};
+var lamba = new LambaManager();
+if (typeof window !== "undefined") {
+  window.lamba = lamba;
+  const isCdnScript = document.currentScript !== null || !!document.querySelector('script[src*="lamba"]');
+  if (isCdnScript) {
+    lamba.init();
+  }
+}
+
+// src/integrations/react.ts
+function useLambaEnv(key, defaultValue = "") {
+  const [value, setValue] = useState(
+    () => lamba.get(key, defaultValue)
+  );
+  useEffect(() => {
+    setValue(lamba.get(key, defaultValue));
+    const unsubscribe = lamba.onChange((changedKey) => {
+      if (changedKey === key) {
+        setValue(lamba.get(key, defaultValue));
+      }
+    });
+    return () => {
+      unsubscribe();
+    };
+  }, [key, defaultValue]);
+  return value;
+}
+export {
+  useLambaEnv
+};
+//# sourceMappingURL=react.mjs.map