@thehoneyjar/sigil-dev-toolbar 0.1.0

package/dist/index.cjs

@@ -0,0 +1,2404 @@
+'use strict';
+
+var react = require('react');
+var zustand = require('zustand');
+var middleware = require('zustand/middleware');
+var jsxRuntime = require('react/jsx-runtime');
+var wagmi = require('wagmi');
+var viem = require('viem');
+
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+var initialState = {
+  visible: true,
+  collapsed: true,
+  activeTab: "lens",
+  userLens: {
+    enabled: false,
+    impersonatedAddress: null,
+    savedAddresses: []
+  },
+  simulation: {
+    enabled: false,
+    scenario: null
+  },
+  comparison: {
+    enabled: false,
+    beforeState: null,
+    afterState: null
+  },
+  diagnostics: {
+    enabled: false,
+    violations: [],
+    tasteSignals: []
+  }
+};
+var createDevToolbarStore = (config) => zustand.create()(
+  middleware.persist(
+    (set, get) => ({
+      ...initialState,
+      collapsed: config.defaultCollapsed ?? true,
+      // Visibility
+      show: () => set({ visible: true }),
+      hide: () => set({ visible: false }),
+      toggle: () => set((state) => ({ visible: !state.visible })),
+      collapse: () => set({ collapsed: true }),
+      expand: () => set({ collapsed: false }),
+      setActiveTab: (tab) => set({ activeTab: tab, collapsed: false }),
+      // User Lens
+      enableLens: (address) => set({
+        userLens: {
+          ...get().userLens,
+          enabled: true,
+          impersonatedAddress: address
+        }
+      }),
+      disableLens: () => set({
+        userLens: {
+          ...get().userLens,
+          enabled: false
+        }
+      }),
+      setImpersonatedAddress: (address) => set({
+        userLens: {
+          ...get().userLens,
+          impersonatedAddress: address,
+          enabled: address !== null
+        }
+      }),
+      saveAddress: (entry) => set({
+        userLens: {
+          ...get().userLens,
+          savedAddresses: [
+            ...get().userLens.savedAddresses.filter((a) => a.address !== entry.address),
+            entry
+          ]
+        }
+      }),
+      removeAddress: (address) => set({
+        userLens: {
+          ...get().userLens,
+          savedAddresses: get().userLens.savedAddresses.filter((a) => a.address !== address)
+        }
+      }),
+      // Simulation
+      enableSimulation: (scenario) => set({
+        simulation: {
+          enabled: true,
+          scenario
+        }
+      }),
+      disableSimulation: () => set({
+        simulation: {
+          enabled: false,
+          scenario: null
+        }
+      }),
+      // Comparison
+      captureBeforeState: (state) => set({
+        comparison: {
+          ...get().comparison,
+          enabled: true,
+          beforeState: state
+        }
+      }),
+      captureAfterState: (state) => set({
+        comparison: {
+          ...get().comparison,
+          afterState: state
+        }
+      }),
+      clearComparison: () => set({
+        comparison: {
+          enabled: false,
+          beforeState: null,
+          afterState: null
+        }
+      }),
+      // Diagnostics
+      addViolation: (violation) => set({
+        diagnostics: {
+          ...get().diagnostics,
+          violations: [...get().diagnostics.violations.slice(-49), violation]
+        }
+      }),
+      clearViolations: () => set({
+        diagnostics: {
+          ...get().diagnostics,
+          violations: []
+        }
+      }),
+      addTasteSignal: (signal) => {
+        set({
+          diagnostics: {
+            ...get().diagnostics,
+            tasteSignals: [...get().diagnostics.tasteSignals.slice(-49), signal]
+          }
+        });
+        config.onTasteSignal?.(signal);
+      },
+      clearTasteSignals: () => set({
+        diagnostics: {
+          ...get().diagnostics,
+          tasteSignals: []
+        }
+      }),
+      // Reset
+      reset: () => set(initialState)
+    }),
+    {
+      name: "sigil-dev-toolbar",
+      partialize: (state) => ({
+        collapsed: state.collapsed,
+        activeTab: state.activeTab,
+        userLens: {
+          savedAddresses: state.userLens.savedAddresses
+        }
+      })
+    }
+  )
+);
+var DevToolbarContext = react.createContext(null);
+var DevToolbarConfigContext = react.createContext(null);
+var defaultConfig = {
+  position: "bottom-right",
+  defaultCollapsed: true,
+  enableUserLens: true,
+  enableSimulation: true,
+  enableComparison: true,
+  enableDiagnostics: true,
+  toggleShortcut: "ctrl+shift+d"
+};
+function DevToolbarProvider({ children, config: userConfig }) {
+  const config = react.useMemo(() => ({ ...defaultConfig, ...userConfig }), [userConfig]);
+  const store = react.useMemo(() => createDevToolbarStore(config), [config]);
+  react.useEffect(() => {
+    const handleKeyDown = (e) => {
+      const keys = config.toggleShortcut.toLowerCase().split("+");
+      const ctrlMatch = keys.includes("ctrl") === (e.ctrlKey || e.metaKey);
+      const shiftMatch = keys.includes("shift") === e.shiftKey;
+      const altMatch = keys.includes("alt") === e.altKey;
+      const keyMatch = keys.filter((k) => !["ctrl", "shift", "alt"].includes(k))[0] === e.key.toLowerCase();
+      if (ctrlMatch && shiftMatch && altMatch && keyMatch) {
+        e.preventDefault();
+        store.getState().toggle();
+      }
+    };
+    window.addEventListener("keydown", handleKeyDown);
+    return () => window.removeEventListener("keydown", handleKeyDown);
+  }, [config.toggleShortcut, store]);
+  return /* @__PURE__ */ jsxRuntime.jsx(DevToolbarConfigContext.Provider, { value: config, children: /* @__PURE__ */ jsxRuntime.jsx(DevToolbarContext.Provider, { value: store, children }) });
+}
+function useDevToolbar() {
+  const store = react.useContext(DevToolbarContext);
+  if (!store) {
+    throw new Error("useDevToolbar must be used within a DevToolbarProvider");
+  }
+  return store();
+}
+function useDevToolbarSelector(selector) {
+  const store = react.useContext(DevToolbarContext);
+  if (!store) {
+    throw new Error("useDevToolbarSelector must be used within a DevToolbarProvider");
+  }
+  return store(selector);
+}
+function useDevToolbarConfig() {
+  const config = react.useContext(DevToolbarConfigContext);
+  if (!config) {
+    throw new Error("useDevToolbarConfig must be used within a DevToolbarProvider");
+  }
+  return config;
+}
+function useLensAwareAccount() {
+  const { address: realAddress, isConnected } = wagmi.useAccount();
+  const userLens = useDevToolbarSelector((state) => state.userLens);
+  const isImpersonating = userLens.enabled && userLens.impersonatedAddress !== null;
+  const address = isImpersonating ? userLens.impersonatedAddress : realAddress;
+  return {
+    address,
+    realAddress,
+    isImpersonating,
+    impersonatedAddress: userLens.impersonatedAddress,
+    isConnected
+  };
+}
+function useIsImpersonating() {
+  return useDevToolbarSelector(
+    (state) => state.userLens.enabled && state.userLens.impersonatedAddress !== null
+  );
+}
+function useImpersonatedAddress() {
+  return useDevToolbarSelector(
+    (state) => state.userLens.enabled ? state.userLens.impersonatedAddress : null
+  );
+}
+function useSavedAddresses() {
+  const savedAddresses = useDevToolbarSelector((state) => state.userLens.savedAddresses);
+  const { saveAddress, removeAddress, setImpersonatedAddress } = useDevToolbarSelector((state) => ({
+    saveAddress: state.saveAddress,
+    removeAddress: state.removeAddress,
+    setImpersonatedAddress: state.setImpersonatedAddress
+  }));
+  return {
+    savedAddresses,
+    saveAddress,
+    removeAddress,
+    selectAddress: setImpersonatedAddress
+  };
+}
+
+// src/ipc/types.ts
+var DEFAULT_IPC_CONFIG = {
+  basePath: "grimoires/pub",
+  timeout: 3e4,
+  pollInterval: 100
+};
+
+// src/ipc/client.ts
+function generateUUID() {
+  if (typeof crypto !== "undefined" && crypto.randomUUID) {
+    return crypto.randomUUID();
+  }
+  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+    const r = Math.random() * 16 | 0;
+    const v = c === "x" ? r : r & 3 | 8;
+    return v.toString(16);
+  });
+}
+var LocalStorageTransport = class {
+  constructor(prefix = "sigil-ipc") {
+    __publicField(this, "prefix");
+    this.prefix = prefix;
+  }
+  async writeRequest(request) {
+    const key = `${this.prefix}:request:${request.id}`;
+    localStorage.setItem(key, JSON.stringify(request));
+  }
+  async readResponse(requestId, cliType) {
+    const key = `${this.prefix}:response:${requestId}:${cliType}`;
+    const data = localStorage.getItem(key);
+    if (!data)
+      return null;
+    try {
+      return JSON.parse(data);
+    } catch {
+      return null;
+    }
+  }
+  async cleanup(requestId) {
+    const keysToRemove = [];
+    for (let i = 0; i < localStorage.length; i++) {
+      const key = localStorage.key(i);
+      if (key?.includes(requestId)) {
+        keysToRemove.push(key);
+      }
+    }
+    keysToRemove.forEach((key) => localStorage.removeItem(key));
+  }
+};
+var MockTransport = class {
+  constructor() {
+    __publicField(this, "mockResponses", /* @__PURE__ */ new Map());
+  }
+  setMockResponse(requestId, cliType, response) {
+    this.mockResponses.set(`${requestId}:${cliType}`, response);
+  }
+  async writeRequest(_request) {
+  }
+  async readResponse(requestId, cliType) {
+    return this.mockResponses.get(`${requestId}:${cliType}`) ?? null;
+  }
+  async cleanup(_requestId) {
+  }
+};
+var IPCClient = class {
+  constructor(transport, config) {
+    __publicField(this, "config");
+    __publicField(this, "transport");
+    this.config = { ...DEFAULT_IPC_CONFIG, ...config };
+    this.transport = transport ?? new LocalStorageTransport();
+  }
+  /**
+   * Send a request and wait for response
+   */
+  async send(type, payload, cliType = "anchor") {
+    const request = {
+      id: generateUUID(),
+      type,
+      timestamp: Date.now(),
+      payload
+    };
+    await this.transport.writeRequest(request);
+    const response = await this.waitForResponse(request.id, cliType);
+    await this.transport.cleanup(request.id);
+    if (response.status === "error") {
+      throw new Error(response.error ?? "Unknown IPC error");
+    }
+    if (response.status === "timeout") {
+      throw new Error("IPC request timed out");
+    }
+    return response.data;
+  }
+  /**
+   * Poll for response until timeout
+   */
+  async waitForResponse(requestId, cliType) {
+    const startTime = Date.now();
+    while (Date.now() - startTime < this.config.timeout) {
+      const response = await this.transport.readResponse(requestId, cliType);
+      if (response) {
+        return response;
+      }
+      await new Promise((resolve) => setTimeout(resolve, this.config.pollInterval));
+    }
+    return {
+      requestId,
+      status: "timeout",
+      timestamp: Date.now(),
+      error: "Request timed out"
+    };
+  }
+  /**
+   * Validate lens context via Anchor CLI
+   */
+  async validateLensContext(context, zone) {
+    const payload = { context, zone };
+    return this.send("lens-validate", payload, "anchor");
+  }
+  /**
+   * Run full Anchor validation with optional lens context
+   */
+  async validateAnchor(statement, lensContext, zone) {
+    const payload = { statement, lensContext, zone };
+    return this.send("anchor-validate", payload, "anchor");
+  }
+  /**
+   * Get the current transport
+   */
+  getTransport() {
+    return this.transport;
+  }
+  /**
+   * Set a new transport
+   */
+  setTransport(transport) {
+    this.transport = transport;
+  }
+};
+var defaultClient = null;
+function getIPCClient() {
+  if (!defaultClient) {
+    defaultClient = new IPCClient();
+  }
+  return defaultClient;
+}
+function resetIPCClient() {
+  defaultClient = null;
+}
+
+// src/hooks/useIPCClient.ts
+function useIPCClient() {
+  const [isLoading, setIsLoading] = react.useState(false);
+  const [error, setError] = react.useState(null);
+  const clientRef = react.useRef(null);
+  const getClient = react.useCallback(() => {
+    if (!clientRef.current) {
+      clientRef.current = getIPCClient();
+    }
+    return clientRef.current;
+  }, []);
+  const validateLens = react.useCallback(
+    async (context, zone) => {
+      setIsLoading(true);
+      setError(null);
+      try {
+        const client = getClient();
+        const result = await client.validateLensContext(context, zone);
+        return result;
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "Unknown error";
+        setError(message);
+        throw err;
+      } finally {
+        setIsLoading(false);
+      }
+    },
+    [getClient]
+  );
+  const validateAnchor = react.useCallback(
+    async (statement, lensContext, zone) => {
+      setIsLoading(true);
+      setError(null);
+      try {
+        const client = getClient();
+        const result = await client.validateAnchor(statement, lensContext, zone);
+        return result;
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "Unknown error";
+        setError(message);
+        throw err;
+      } finally {
+        setIsLoading(false);
+      }
+    },
+    [getClient]
+  );
+  const clearError = react.useCallback(() => {
+    setError(null);
+  }, []);
+  return {
+    validateLens,
+    validateAnchor,
+    isLoading,
+    error,
+    clearError
+  };
+}
+
+// src/services/fork.ts
+function createAnvilForkService() {
+  let state = {
+    active: false,
+    rpcUrl: null,
+    blockNumber: null,
+    chainId: null,
+    createdAt: null,
+    snapshotCount: 0,
+    currentSnapshotId: null
+  };
+  const snapshots = /* @__PURE__ */ new Map();
+  async function jsonRpc(method, params = []) {
+    if (!state.rpcUrl) {
+      throw new Error("Fork not active");
+    }
+    const response = await fetch(state.rpcUrl, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        jsonrpc: "2.0",
+        id: Date.now(),
+        method,
+        params
+      })
+    });
+    const data = await response.json();
+    if (data.error) {
+      throw new Error(data.error.message || "RPC error");
+    }
+    return data.result;
+  }
+  return {
+    async createFork(config) {
+      const rpcUrl = config.customForkRpc || `http://127.0.0.1:${config.anvilPort || 8545}`;
+      try {
+        const chainIdHex = await fetch(rpcUrl, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({
+            jsonrpc: "2.0",
+            id: 1,
+            method: "eth_chainId",
+            params: []
+          })
+        }).then((r) => r.json()).then((d) => d.result);
+        const blockNumberHex = await fetch(rpcUrl, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({
+            jsonrpc: "2.0",
+            id: 2,
+            method: "eth_blockNumber",
+            params: []
+          })
+        }).then((r) => r.json()).then((d) => d.result);
+        state = {
+          active: true,
+          rpcUrl,
+          blockNumber: BigInt(blockNumberHex),
+          chainId: parseInt(chainIdHex, 16),
+          createdAt: Date.now(),
+          snapshotCount: 0,
+          currentSnapshotId: null
+        };
+        return state;
+      } catch (error) {
+        throw new Error(`Failed to connect to Anvil at ${rpcUrl}: ${error instanceof Error ? error.message : "Unknown error"}`);
+      }
+    },
+    getState() {
+      return { ...state };
+    },
+    async snapshot(description) {
+      const result = await jsonRpc("evm_snapshot");
+      const id = result;
+      const blockNumberHex = await jsonRpc("eth_blockNumber");
+      const snapshot = {
+        id,
+        blockNumber: BigInt(blockNumberHex),
+        timestamp: Date.now(),
+        description
+      };
+      snapshots.set(id, snapshot);
+      state.snapshotCount++;
+      state.currentSnapshotId = id;
+      return snapshot;
+    },
+    async revert(snapshotId) {
+      const result = await jsonRpc("evm_revert", [snapshotId]);
+      if (result) {
+        state.currentSnapshotId = snapshotId;
+      }
+      return result;
+    },
+    async reset() {
+      await jsonRpc("anvil_reset");
+      snapshots.clear();
+      state.snapshotCount = 0;
+      state.currentSnapshotId = null;
+    },
+    async destroy() {
+      state = {
+        active: false,
+        rpcUrl: null,
+        blockNumber: null,
+        chainId: null,
+        createdAt: null,
+        snapshotCount: 0,
+        currentSnapshotId: null
+      };
+      snapshots.clear();
+    },
+    async setBalance(address, balance) {
+      await jsonRpc("anvil_setBalance", [address, `0x${balance.toString(16)}`]);
+    },
+    async impersonateAccount(address) {
+      await jsonRpc("anvil_impersonateAccount", [address]);
+    },
+    async stopImpersonating(address) {
+      await jsonRpc("anvil_stopImpersonatingAccount", [address]);
+    },
+    async mineBlock(blocks = 1) {
+      await jsonRpc("anvil_mine", [blocks]);
+    },
+    getRpcUrl() {
+      return state.rpcUrl;
+    }
+  };
+}
+function createTenderlyForkService() {
+  let state = {
+    active: false,
+    rpcUrl: null,
+    blockNumber: null,
+    chainId: null,
+    createdAt: null,
+    snapshotCount: 0,
+    currentSnapshotId: null
+  };
+  let forkId = null;
+  let config = null;
+  async function tenderlyApi(endpoint, method = "GET", body) {
+    if (!config?.tenderlyApiKey || !config?.tenderlyProject) {
+      throw new Error("Tenderly API key and project required");
+    }
+    const response = await fetch(`https://api.tenderly.co/api/v1/account/${config.tenderlyProject}/project/${config.tenderlyProject}${endpoint}`, {
+      method,
+      headers: {
+        "Content-Type": "application/json",
+        "X-Access-Key": config.tenderlyApiKey
+      },
+      body: body ? JSON.stringify(body) : void 0
+    });
+    if (!response.ok) {
+      throw new Error(`Tenderly API error: ${response.statusText}`);
+    }
+    return response.json();
+  }
+  return {
+    async createFork(cfg) {
+      config = cfg;
+      const forkResponse = await tenderlyApi("/fork", "POST", {
+        network_id: cfg.chainId.toString(),
+        block_number: cfg.forkBlockNumber ? Number(cfg.forkBlockNumber) : void 0
+      });
+      forkId = forkResponse.simulation_fork.id;
+      state = {
+        active: true,
+        rpcUrl: forkResponse.simulation_fork.rpc_url,
+        blockNumber: BigInt(forkResponse.simulation_fork.block_number),
+        chainId: cfg.chainId,
+        createdAt: Date.now(),
+        snapshotCount: 0,
+        currentSnapshotId: null
+      };
+      return state;
+    },
+    getState() {
+      return { ...state };
+    },
+    async snapshot(description) {
+      if (!forkId)
+        throw new Error("Fork not active");
+      const response = await tenderlyApi(`/fork/${forkId}/snapshot`, "POST");
+      const snapshot = {
+        id: response.snapshot.id,
+        blockNumber: BigInt(response.snapshot.block_number),
+        timestamp: Date.now(),
+        description
+      };
+      state.snapshotCount++;
+      state.currentSnapshotId = snapshot.id;
+      return snapshot;
+    },
+    async revert(snapshotId) {
+      if (!forkId)
+        throw new Error("Fork not active");
+      try {
+        await tenderlyApi(`/fork/${forkId}/snapshot/${snapshotId}`, "PUT");
+        state.currentSnapshotId = snapshotId;
+        return true;
+      } catch {
+        return false;
+      }
+    },
+    async reset() {
+      if (!forkId || !config)
+        throw new Error("Fork not active");
+      await tenderlyApi(`/fork/${forkId}`, "DELETE");
+      await this.createFork(config);
+    },
+    async destroy() {
+      if (forkId) {
+        try {
+          await tenderlyApi(`/fork/${forkId}`, "DELETE");
+        } catch {
+        }
+      }
+      state = {
+        active: false,
+        rpcUrl: null,
+        blockNumber: null,
+        chainId: null,
+        createdAt: null,
+        snapshotCount: 0,
+        currentSnapshotId: null
+      };
+      forkId = null;
+      config = null;
+    },
+    async setBalance(address, balance) {
+      if (!state.rpcUrl)
+        throw new Error("Fork not active");
+      await fetch(state.rpcUrl, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          jsonrpc: "2.0",
+          id: Date.now(),
+          method: "tenderly_setBalance",
+          params: [address, `0x${balance.toString(16)}`]
+        })
+      });
+    },
+    async impersonateAccount(_address) {
+    },
+    async stopImpersonating(_address) {
+    },
+    async mineBlock(blocks = 1) {
+      if (!state.rpcUrl)
+        throw new Error("Fork not active");
+      await fetch(state.rpcUrl, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          jsonrpc: "2.0",
+          id: Date.now(),
+          method: "evm_increaseTime",
+          params: [blocks * 12]
+          // 12 seconds per block
+        })
+      });
+    },
+    getRpcUrl() {
+      return state.rpcUrl;
+    }
+  };
+}
+function createForkService(provider) {
+  switch (provider) {
+    case "anvil":
+      return createAnvilForkService();
+    case "tenderly":
+      return createTenderlyForkService();
+    case "custom":
+      return createAnvilForkService();
+    default:
+      throw new Error(`Unknown fork provider: ${provider}`);
+  }
+}
+var defaultForkService = null;
+function getForkService(provider = "anvil") {
+  if (!defaultForkService) {
+    defaultForkService = createForkService(provider);
+  }
+  return defaultForkService;
+}
+function resetForkService() {
+  if (defaultForkService) {
+    defaultForkService.destroy();
+    defaultForkService = null;
+  }
+}
+
+// src/hooks/useForkState.ts
+function useForkState(defaultProvider = "anvil") {
+  const [state, setState] = react.useState({
+    active: false,
+    rpcUrl: null,
+    blockNumber: null,
+    chainId: null,
+    createdAt: null,
+    snapshotCount: 0,
+    currentSnapshotId: null
+  });
+  const [isLoading, setIsLoading] = react.useState(false);
+  const [error, setError] = react.useState(null);
+  const [snapshots, setSnapshots] = react.useState([]);
+  const serviceRef = react.useRef(null);
+  react.useEffect(() => {
+    serviceRef.current = createForkService(defaultProvider);
+    return () => {
+      if (serviceRef.current) {
+        serviceRef.current.destroy();
+        serviceRef.current = null;
+      }
+    };
+  }, [defaultProvider]);
+  const createFork = react.useCallback(async (config) => {
+    if (!serviceRef.current) {
+      serviceRef.current = createForkService(config.provider);
+    }
+    setIsLoading(true);
+    setError(null);
+    try {
+      const newState = await serviceRef.current.createFork(config);
+      setState(newState);
+      setSnapshots([]);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "Failed to create fork";
+      setError(message);
+      throw err;
+    } finally {
+      setIsLoading(false);
+    }
+  }, []);
+  const snapshot = react.useCallback(async (description) => {
+    if (!serviceRef.current) {
+      setError("Fork service not initialized");
+      return null;
+    }
+    setIsLoading(true);
+    setError(null);
+    try {
+      const snap = await serviceRef.current.snapshot(description);
+      setSnapshots((prev) => [...prev, snap]);
+      setState(serviceRef.current.getState());
+      return snap;
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "Failed to take snapshot";
+      setError(message);
+      return null;
+    } finally {
+      setIsLoading(false);
+    }
+  }, []);
+  const revert = react.useCallback(async (snapshotId) => {
+    if (!serviceRef.current) {
+      setError("Fork service not initialized");
+      return false;
+    }
+    setIsLoading(true);
+    setError(null);
+    try {
+      const success = await serviceRef.current.revert(snapshotId);
+      if (success) {
+        setState(serviceRef.current.getState());
+      }
+      return success;
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "Failed to revert";
+      setError(message);
+      return false;
+    } finally {
+      setIsLoading(false);
+    }
+  }, []);
+  const reset = react.useCallback(async () => {
+    if (!serviceRef.current) {
+      setError("Fork service not initialized");
+      return;
+    }
+    setIsLoading(true);
+    setError(null);
+    try {
+      await serviceRef.current.reset();
+      setState(serviceRef.current.getState());
+      setSnapshots([]);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "Failed to reset";
+      setError(message);
+    } finally {
+      setIsLoading(false);
+    }
+  }, []);
+  const destroy = react.useCallback(async () => {
+    if (!serviceRef.current)
+      return;
+    setIsLoading(true);
+    setError(null);
+    try {
+      await serviceRef.current.destroy();
+      setState({
+        active: false,
+        rpcUrl: null,
+        blockNumber: null,
+        chainId: null,
+        createdAt: null,
+        snapshotCount: 0,
+        currentSnapshotId: null
+      });
+      setSnapshots([]);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "Failed to destroy fork";
+      setError(message);
+    } finally {
+      setIsLoading(false);
+    }
+  }, []);
+  const setBalance = react.useCallback(async (address, balance) => {
+    if (!serviceRef.current) {
+      setError("Fork service not initialized");
+      return;
+    }
+    setIsLoading(true);
+    setError(null);
+    try {
+      await serviceRef.current.setBalance(address, balance);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "Failed to set balance";
+      setError(message);
+    } finally {
+      setIsLoading(false);
+    }
+  }, []);
+  const impersonateAccount = react.useCallback(async (address) => {
+    if (!serviceRef.current) {
+      setError("Fork service not initialized");
+      return;
+    }
+    setIsLoading(true);
+    setError(null);
+    try {
+      await serviceRef.current.impersonateAccount(address);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "Failed to impersonate account";
+      setError(message);
+    } finally {
+      setIsLoading(false);
+    }
+  }, []);
+  const stopImpersonating = react.useCallback(async (address) => {
+    if (!serviceRef.current) {
+      setError("Fork service not initialized");
+      return;
+    }
+    setIsLoading(true);
+    setError(null);
+    try {
+      await serviceRef.current.stopImpersonating(address);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "Failed to stop impersonating";
+      setError(message);
+    } finally {
+      setIsLoading(false);
+    }
+  }, []);
+  const mineBlock = react.useCallback(async (blocks = 1) => {
+    if (!serviceRef.current) {
+      setError("Fork service not initialized");
+      return;
+    }
+    setIsLoading(true);
+    setError(null);
+    try {
+      await serviceRef.current.mineBlock(blocks);
+      setState(serviceRef.current.getState());
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "Failed to mine block";
+      setError(message);
+    } finally {
+      setIsLoading(false);
+    }
+  }, []);
+  return {
+    state,
+    isLoading,
+    error,
+    createFork,
+    snapshot,
+    revert,
+    reset,
+    destroy,
+    setBalance,
+    impersonateAccount,
+    stopImpersonating,
+    mineBlock,
+    snapshots
+  };
+}
+
+// src/services/simulation.ts
+function parseRevertReason(data) {
+  if (data.startsWith("0x08c379a0") && data.length >= 138) {
+    try {
+      const lengthHex = data.slice(74, 138);
+      const length = parseInt(lengthHex, 16);
+      if (length > 0 && length < 1e3) {
+        const messageHex = data.slice(138, 138 + length * 2);
+        const message = Buffer.from(messageHex, "hex").toString("utf8");
+        return message;
+      }
+    } catch {
+    }
+  }
+  if (data.startsWith("0x4e487b71") && data.length >= 74) {
+    const panicCode = parseInt(data.slice(10, 74), 16);
+    const panicMessages = {
+      0: "Generic compiler panic",
+      1: "Assert failed",
+      17: "Arithmetic overflow/underflow",
+      18: "Division by zero",
+      33: "Invalid enum value",
+      34: "Invalid storage byte array",
+      49: "Pop on empty array",
+      50: "Array index out of bounds",
+      65: "Too much memory allocated",
+      81: "Internal function called"
+    };
+    return panicMessages[panicCode] || `Panic(0x${panicCode.toString(16)})`;
+  }
+  if (data.length > 10) {
+    const selector = data.slice(0, 10);
+    return `Custom error: ${selector}`;
+  }
+  return null;
+}
+function createSimulationService(forkService) {
+  async function jsonRpc(method, params = []) {
+    const rpcUrl = forkService.getRpcUrl();
+    if (!rpcUrl) {
+      throw new Error("Fork not active");
+    }
+    const response = await fetch(rpcUrl, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        jsonrpc: "2.0",
+        id: Date.now(),
+        method,
+        params
+      })
+    });
+    const data = await response.json();
+    if (data.error) {
+      throw new Error(data.error.message || "RPC error");
+    }
+    return data.result;
+  }
+  async function getBalance(address) {
+    const result = await jsonRpc("eth_getBalance", [address, "latest"]);
+    return BigInt(result);
+  }
+  return {
+    async simulate(tx) {
+      const timestamp = Date.now();
+      const blockNumberHex = await jsonRpc("eth_blockNumber");
+      const blockNumber = BigInt(blockNumberHex);
+      const fromBalanceBefore = await getBalance(tx.from);
+      const toBalanceBefore = await getBalance(tx.to);
+      const gasLimit = tx.gas ?? await this.estimateGas(tx);
+      const gasPrice = tx.gasPrice ?? tx.maxFeePerGas ?? await this.getGasPrice();
+      const snapshot = await forkService.snapshot("pre-simulation");
+      const txParams = {
+        from: tx.from,
+        to: tx.to,
+        value: tx.value ? `0x${tx.value.toString(16)}` : "0x0",
+        data: tx.data ?? "0x",
+        gas: `0x${gasLimit.toString(16)}`,
+        gasPrice: `0x${gasPrice.toString(16)}`,
+        nonce: tx.nonce !== void 0 ? `0x${tx.nonce.toString(16)}` : void 0
+      };
+      let success = true;
+      let hash;
+      let gasUsed = 0n;
+      let returnValue;
+      let revertReason;
+      const logs = [];
+      try {
+        await forkService.impersonateAccount(tx.from);
+        hash = await jsonRpc("eth_sendTransaction", [txParams]);
+        let receipt = null;
+        let attempts = 0;
+        while (!receipt && attempts < 50) {
+          await new Promise((resolve) => setTimeout(resolve, 100));
+          receipt = await jsonRpc("eth_getTransactionReceipt", [hash]);
+          attempts++;
+        }
+        if (receipt) {
+          const r = receipt;
+          success = r.status === "0x1";
+          gasUsed = BigInt(r.gasUsed);
+          for (const log of r.logs) {
+            logs.push({
+              address: log.address,
+              topics: log.topics,
+              data: log.data
+            });
+          }
+          if (!success) {
+            try {
+              await jsonRpc("eth_call", [txParams, "latest"]);
+            } catch (callError) {
+              if (callError instanceof Error && callError.message) {
+                revertReason = callError.message;
+              }
+            }
+          }
+        }
+      } catch (error) {
+        success = false;
+        if (error instanceof Error) {
+          const errorData = error.data;
+          if (errorData) {
+            revertReason = parseRevertReason(errorData) ?? error.message;
+          } else {
+            revertReason = error.message;
+          }
+        }
+      } finally {
+        try {
+          await forkService.stopImpersonating(tx.from);
+        } catch {
+        }
+      }
+      const fromBalanceAfter = await getBalance(tx.from);
+      const toBalanceAfter = await getBalance(tx.to);
+      const balanceChanges = [];
+      if (fromBalanceBefore !== fromBalanceAfter) {
+        balanceChanges.push({
+          address: tx.from,
+          token: null,
+          symbol: "ETH",
+          before: fromBalanceBefore,
+          after: fromBalanceAfter,
+          delta: fromBalanceAfter - fromBalanceBefore
+        });
+      }
+      if (tx.from !== tx.to && toBalanceBefore !== toBalanceAfter) {
+        balanceChanges.push({
+          address: tx.to,
+          token: null,
+          symbol: "ETH",
+          before: toBalanceBefore,
+          after: toBalanceAfter,
+          delta: toBalanceAfter - toBalanceBefore
+        });
+      }
+      await forkService.revert(snapshot.id);
+      const effectiveGasPrice = gasPrice;
+      const totalCost = gasUsed * effectiveGasPrice + (tx.value ?? 0n);
+      return {
+        success,
+        hash,
+        gasUsed,
+        gasLimit,
+        effectiveGasPrice,
+        totalCost,
+        returnValue,
+        revertReason,
+        balanceChanges,
+        stateChanges: [],
+        // State changes require trace API
+        logs,
+        blockNumber,
+        timestamp
+      };
+    },
+    async estimateGas(tx) {
+      const txParams = {
+        from: tx.from,
+        to: tx.to,
+        value: tx.value ? `0x${tx.value.toString(16)}` : "0x0",
+        data: tx.data ?? "0x"
+      };
+      try {
+        const result = await jsonRpc("eth_estimateGas", [txParams]);
+        const estimate = BigInt(result);
+        return estimate * 120n / 100n;
+      } catch (error) {
+        return 21000n;
+      }
+    },
+    async getGasPrice() {
+      const result = await jsonRpc("eth_gasPrice");
+      return BigInt(result);
+    },
+    decodeRevertReason(data) {
+      return parseRevertReason(data);
+    }
+  };
+}
+var defaultSimulationService = null;
+function getSimulationService(forkService) {
+  if (!defaultSimulationService) {
+    defaultSimulationService = createSimulationService(forkService);
+  }
+  return defaultSimulationService;
+}
+function resetSimulationService() {
+  defaultSimulationService = null;
+}
+
+// src/hooks/useTransactionSimulation.ts
+function useTransactionSimulation(config = {}) {
+  const {
+    provider = "anvil",
+    forkUrl,
+    chainId = 1,
+    anvilPort = 8545,
+    autoConnect = false,
+    from
+  } = config;
+  const [result, setResult] = react.useState(null);
+  const [isSimulating, setIsSimulating] = react.useState(false);
+  const [isConnected, setIsConnected] = react.useState(false);
+  const [isConnecting, setIsConnecting] = react.useState(false);
+  const [error, setError] = react.useState(null);
+  const forkServiceRef = react.useRef(null);
+  const simulationServiceRef = react.useRef(null);
+  const fromAddressRef = react.useRef(from);
+  react.useEffect(() => {
+    fromAddressRef.current = from;
+  }, [from]);
+  const connect = react.useCallback(async (overrideConfig) => {
+    if (isConnected || isConnecting)
+      return;
+    setIsConnecting(true);
+    setError(null);
+    try {
+      const forkConfig = {
+        provider: overrideConfig?.provider ?? provider,
+        forkUrl: overrideConfig?.forkUrl ?? forkUrl ?? "",
+        chainId: overrideConfig?.chainId ?? chainId,
+        anvilPort: overrideConfig?.anvilPort ?? anvilPort,
+        customForkRpc: overrideConfig?.customForkRpc
+      };
+      forkServiceRef.current = createForkService(forkConfig.provider);
+      await forkServiceRef.current.createFork(forkConfig);
+      simulationServiceRef.current = createSimulationService(forkServiceRef.current);
+      setIsConnected(true);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "Failed to connect to fork";
+      setError(message);
+      forkServiceRef.current = null;
+      simulationServiceRef.current = null;
+    } finally {
+      setIsConnecting(false);
+    }
+  }, [isConnected, isConnecting, provider, forkUrl, chainId, anvilPort]);
+  const disconnect = react.useCallback(async () => {
+    if (forkServiceRef.current) {
+      await forkServiceRef.current.destroy();
+      forkServiceRef.current = null;
+      simulationServiceRef.current = null;
+    }
+    setIsConnected(false);
+    setResult(null);
+    setError(null);
+  }, []);
+  react.useEffect(() => {
+    if (autoConnect) {
+      connect();
+    }
+    return () => {
+      if (forkServiceRef.current) {
+        forkServiceRef.current.destroy();
+      }
+    };
+  }, []);
+  const simulate = react.useCallback(async (tx) => {
+    if (!simulationServiceRef.current || !forkServiceRef.current) {
+      setError("Not connected to fork. Call connect() first.");
+      return null;
+    }
+    const senderAddress = fromAddressRef.current;
+    if (!senderAddress) {
+      setError('No sender address provided. Set "from" in config.');
+      return null;
+    }
+    setIsSimulating(true);
+    setError(null);
+    try {
+      const request = {
+        from: senderAddress,
+        to: tx.to,
+        data: tx.data,
+        value: tx.value,
+        gas: tx.gas
+      };
+      const simResult = await simulationServiceRef.current.simulate(request);
+      setResult(simResult);
+      return simResult;
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "Simulation failed";
+      setError(message);
+      return null;
+    } finally {
+      setIsSimulating(false);
+    }
+  }, []);
+  const clearResult = react.useCallback(() => {
+    setResult(null);
+    setError(null);
+  }, []);
+  const reset = react.useCallback(async () => {
+    if (forkServiceRef.current) {
+      await forkServiceRef.current.reset();
+      setResult(null);
+      setError(null);
+    }
+  }, []);
+  return {
+    result,
+    isSimulating,
+    isConnected,
+    isConnecting,
+    error,
+    simulate,
+    connect,
+    disconnect,
+    clearResult,
+    reset
+  };
+}
+function useSimulation(from, options = {}) {
+  const hook = useTransactionSimulation({
+    ...options,
+    from,
+    autoConnect: true
+  });
+  const { connect: _connect, disconnect: _disconnect, ...rest } = hook;
+  return rest;
+}
+function isValidAddressInput(input) {
+  if (viem.isAddress(input))
+    return true;
+  if (input.endsWith(".eth") && input.length > 4)
+    return true;
+  return false;
+}
+function truncateAddress(address) {
+  if (address.length <= 10)
+    return address;
+  return `${address.slice(0, 6)}...${address.slice(-4)}`;
+}
+function UserLens() {
+  const [input, setInput] = react.useState("");
+  const [error, setError] = react.useState(null);
+  const [isResolving, setIsResolving] = react.useState(false);
+  const { setImpersonatedAddress, disableLens, saveAddress, userLens } = useDevToolbar();
+  const { savedAddresses, selectAddress, removeAddress } = useSavedAddresses();
+  const isImpersonating = useIsImpersonating();
+  const handleSubmit = react.useCallback(
+    async (e) => {
+      e.preventDefault();
+      setError(null);
+      const trimmed = input.trim();
+      if (!trimmed)
+        return;
+      if (!isValidAddressInput(trimmed)) {
+        setError("Invalid address or ENS name");
+        return;
+      }
+      if (viem.isAddress(trimmed)) {
+        setImpersonatedAddress(trimmed);
+        setInput("");
+      } else if (trimmed.endsWith(".eth")) {
+        setIsResolving(true);
+        setError("ENS resolution not yet implemented. Please use address.");
+        setIsResolving(false);
+      }
+    },
+    [input, setImpersonatedAddress]
+  );
+  const handleClear = react.useCallback(() => {
+    disableLens();
+    setInput("");
+    setError(null);
+  }, [disableLens]);
+  const handleSaveCurrentAddress = react.useCallback(() => {
+    const trimmed = input.trim();
+    if (viem.isAddress(trimmed)) {
+      saveAddress({
+        address: trimmed,
+        label: `Address ${savedAddresses.length + 1}`
+      });
+    }
+  }, [input, saveAddress, savedAddresses.length]);
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "sigil-user-lens", children: [
+    /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "sigil-user-lens__header", children: [
+      /* @__PURE__ */ jsxRuntime.jsx("h3", { children: "User Lens" }),
+      isImpersonating && /* @__PURE__ */ jsxRuntime.jsx("span", { className: "sigil-user-lens__badge", children: "Active" })
+    ] }),
+    /* @__PURE__ */ jsxRuntime.jsx("p", { className: "sigil-user-lens__description", children: "View the app as another address. Reads use the impersonated address, transactions still sign with your real wallet." }),
+    /* @__PURE__ */ jsxRuntime.jsxs("form", { onSubmit: handleSubmit, className: "sigil-user-lens__form", children: [
+      /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "sigil-user-lens__input-group", children: [
+        /* @__PURE__ */ jsxRuntime.jsx(
+          "input",
+          {
+            type: "text",
+            value: input,
+            onChange: (e) => setInput(e.target.value),
+            placeholder: "0x... or name.eth",
+            className: "sigil-user-lens__input",
+            disabled: isResolving
+          }
+        ),
+        /* @__PURE__ */ jsxRuntime.jsx(
+          "button",
+          {
+            type: "submit",
+            className: "sigil-user-lens__button sigil-user-lens__button--primary",
+            disabled: isResolving || !input.trim(),
+            children: isResolving ? "Resolving..." : "Impersonate"
+          }
+        )
+      ] }),
+      error && /* @__PURE__ */ jsxRuntime.jsx("p", { className: "sigil-user-lens__error", children: error })
+    ] }),
+    isImpersonating && /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "sigil-user-lens__active", children: [
+      /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "sigil-user-lens__active-header", children: [
+        /* @__PURE__ */ jsxRuntime.jsx("span", { children: "Currently viewing as:" }),
+        /* @__PURE__ */ jsxRuntime.jsx(
+          "button",
+          {
+            onClick: handleClear,
+            className: "sigil-user-lens__button sigil-user-lens__button--danger",
+            children: "Clear"
+          }
+        )
+      ] }),
+      /* @__PURE__ */ jsxRuntime.jsx("code", { className: "sigil-user-lens__address", children: userLens.impersonatedAddress })
+    ] }),
+    savedAddresses.length > 0 && /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "sigil-user-lens__saved", children: [
+      /* @__PURE__ */ jsxRuntime.jsx("h4", { children: "Saved Addresses" }),
+      /* @__PURE__ */ jsxRuntime.jsx("ul", { className: "sigil-user-lens__saved-list", children: savedAddresses.map((entry) => /* @__PURE__ */ jsxRuntime.jsxs("li", { className: "sigil-user-lens__saved-item", children: [
+        /* @__PURE__ */ jsxRuntime.jsxs(
+          "button",
+          {
+            onClick: () => selectAddress(entry.address),
+            className: "sigil-user-lens__saved-button",
+            children: [
+              /* @__PURE__ */ jsxRuntime.jsx("span", { className: "sigil-user-lens__saved-label", children: entry.label }),
+              /* @__PURE__ */ jsxRuntime.jsx("span", { className: "sigil-user-lens__saved-address", children: truncateAddress(entry.address) })
+            ]
+          }
+        ),
+        /* @__PURE__ */ jsxRuntime.jsx(
+          "button",
+          {
+            onClick: () => removeAddress(entry.address),
+            className: "sigil-user-lens__remove",
+            "aria-label": "Remove",
+            children: "\xD7"
+          }
+        )
+      ] }, entry.address)) })
+    ] }),
+    input && viem.isAddress(input) && !savedAddresses.find((a) => a.address === input) && /* @__PURE__ */ jsxRuntime.jsx(
+      "button",
+      {
+        onClick: handleSaveCurrentAddress,
+        className: "sigil-user-lens__button sigil-user-lens__button--secondary",
+        children: "Save Address"
+      }
+    )
+  ] });
+}
+function LensActiveBadge() {
+  const isImpersonating = useIsImpersonating();
+  if (!isImpersonating)
+    return null;
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "sigil-lens-badge", children: [
+    /* @__PURE__ */ jsxRuntime.jsx("span", { className: "sigil-lens-badge__icon", children: "\u{1F441}" }),
+    /* @__PURE__ */ jsxRuntime.jsx("span", { className: "sigil-lens-badge__text", children: "Lens Active" })
+  ] });
+}
+var TABS = [
+  { id: "lens", label: "Lens", icon: "\u{1F441}", configKey: "enableUserLens" },
+  { id: "simulate", label: "Simulate", icon: "\u{1F3AD}", configKey: "enableSimulation" },
+  { id: "compare", label: "Compare", icon: "\u2696\uFE0F", configKey: "enableComparison" },
+  { id: "diagnose", label: "Diagnose", icon: "\u{1F50D}", configKey: "enableDiagnostics" }
+];
+function PlaceholderPanel({ title }) {
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "sigil-toolbar__placeholder", children: [
+    /* @__PURE__ */ jsxRuntime.jsx("h3", { children: title }),
+    /* @__PURE__ */ jsxRuntime.jsx("p", { children: "Coming in Sprint 4+" })
+  ] });
+}
+function TabContent({ tab }) {
+  switch (tab) {
+    case "lens":
+      return /* @__PURE__ */ jsxRuntime.jsx(UserLens, {});
+    case "simulate":
+      return /* @__PURE__ */ jsxRuntime.jsx(PlaceholderPanel, { title: "Simulation" });
+    case "compare":
+      return /* @__PURE__ */ jsxRuntime.jsx(PlaceholderPanel, { title: "State Comparison" });
+    case "diagnose":
+      return /* @__PURE__ */ jsxRuntime.jsx(PlaceholderPanel, { title: "Diagnostics" });
+    default:
+      return null;
+  }
+}
+function DevToolbar() {
+  const config = useDevToolbarConfig();
+  const {
+    visible,
+    collapsed,
+    activeTab,
+    setActiveTab,
+    collapse,
+    expand,
+    toggle,
+    userLens
+  } = useDevToolbar();
+  const handleTabClick = react.useCallback(
+    (tab) => {
+      if (collapsed) {
+        expand();
+      }
+      setActiveTab(tab);
+    },
+    [collapsed, expand, setActiveTab]
+  );
+  const handleToggleCollapse = react.useCallback(() => {
+    if (collapsed) {
+      expand();
+    } else {
+      collapse();
+    }
+  }, [collapsed, collapse, expand]);
+  if (process.env.NODE_ENV === "production") {
+    return null;
+  }
+  if (!visible) {
+    return null;
+  }
+  const enabledTabs = TABS.filter((tab) => config[tab.configKey]);
+  const positionClass = `sigil-toolbar--${config.position}`;
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: `sigil-toolbar ${positionClass} ${collapsed ? "sigil-toolbar--collapsed" : ""}`, children: [
+    /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "sigil-toolbar__header", children: [
+      /* @__PURE__ */ jsxRuntime.jsx("div", { className: "sigil-toolbar__tabs", children: enabledTabs.map((tab) => /* @__PURE__ */ jsxRuntime.jsxs(
+        "button",
+        {
+          onClick: () => handleTabClick(tab.id),
+          className: `sigil-toolbar__tab ${activeTab === tab.id ? "sigil-toolbar__tab--active" : ""}`,
+          title: tab.label,
+          children: [
+            /* @__PURE__ */ jsxRuntime.jsx("span", { className: "sigil-toolbar__tab-icon", children: tab.icon }),
+            !collapsed && /* @__PURE__ */ jsxRuntime.jsx("span", { className: "sigil-toolbar__tab-label", children: tab.label })
+          ]
+        },
+        tab.id
+      )) }),
+      /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "sigil-toolbar__controls", children: [
+        userLens.enabled && collapsed && /* @__PURE__ */ jsxRuntime.jsx("span", { className: "sigil-toolbar__lens-indicator", title: "Lens Active", children: "\u{1F441}" }),
+        /* @__PURE__ */ jsxRuntime.jsx(
+          "button",
+          {
+            onClick: handleToggleCollapse,
+            className: "sigil-toolbar__collapse-btn",
+            "aria-label": collapsed ? "Expand toolbar" : "Collapse toolbar",
+            children: collapsed ? "\u25C0" : "\u25B6"
+          }
+        ),
+        /* @__PURE__ */ jsxRuntime.jsx(
+          "button",
+          {
+            onClick: toggle,
+            className: "sigil-toolbar__close-btn",
+            "aria-label": "Close toolbar",
+            children: "\xD7"
+          }
+        )
+      ] })
+    ] }),
+    !collapsed && /* @__PURE__ */ jsxRuntime.jsx("div", { className: "sigil-toolbar__content", children: /* @__PURE__ */ jsxRuntime.jsx(TabContent, { tab: activeTab }) }),
+    collapsed && /* @__PURE__ */ jsxRuntime.jsx("div", { className: "sigil-toolbar__shortcut-hint", children: config.toggleShortcut })
+  ] });
+}
+function DevToolbarTrigger() {
+  const { visible, show } = useDevToolbar();
+  const config = useDevToolbarConfig();
+  if (process.env.NODE_ENV === "production") {
+    return null;
+  }
+  if (visible) {
+    return null;
+  }
+  const positionClass = `sigil-toolbar-trigger--${config.position}`;
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    "button",
+    {
+      onClick: show,
+      className: `sigil-toolbar-trigger ${positionClass}`,
+      "aria-label": "Open Sigil Dev Toolbar",
+      title: `Sigil Dev Toolbar (${config.toggleShortcut})`,
+      children: /* @__PURE__ */ jsxRuntime.jsx("span", { children: "\u26A1" })
+    }
+  );
+}
+function DevToolbarWithTrigger() {
+  return /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+    /* @__PURE__ */ jsxRuntime.jsx(DevToolbar, {}),
+    /* @__PURE__ */ jsxRuntime.jsx(DevToolbarTrigger, {}),
+    /* @__PURE__ */ jsxRuntime.jsx(LensActiveBadge, {})
+  ] });
+}
+function generateQuestions(issues) {
+  return issues.map((issue, index) => {
+    let question;
+    let severity;
+    switch (issue.type) {
+      case "data_source_mismatch":
+        question = `The ${issue.component} shows "${issue.actual}" but on-chain value is "${issue.expected}". Which is correct?`;
+        severity = issue.severity === "error" ? "critical" : "important";
+        break;
+      case "stale_indexed_data":
+        question = `The indexer shows stale data for ${issue.component}. Expected: "${issue.expected}", Got: "${issue.actual}". Has this been recently updated?`;
+        severity = issue.severity === "error" ? "critical" : "info";
+        break;
+      case "lens_financial_check":
+        question = `${issue.component} uses indexed data for financial operations. Should this use on-chain data instead?`;
+        severity = "critical";
+        break;
+      case "impersonation_leak":
+        question = `${issue.component} appears to show the real address instead of the impersonated one. Is this intentional?`;
+        severity = "critical";
+        break;
+      default:
+        question = issue.message;
+        severity = "info";
+    }
+    return {
+      id: `q-${index}`,
+      question,
+      context: issue.suggestion ?? "",
+      severity
+    };
+  });
+}
+function DiagnosticPanel({
+  items: initialItems = [],
+  autoQuery = false,
+  onDiagnosisComplete
+}) {
+  const [items, setItems] = react.useState(initialItems);
+  const [questions, setQuestions] = react.useState([]);
+  const [isQuerying, setIsQuerying] = react.useState(false);
+  const { validateLens, isLoading, error } = useIPCClient();
+  const { address, isImpersonating, realAddress, impersonatedAddress } = useLensAwareAccount();
+  const diagnosticsState = useDevToolbarSelector((state) => state.diagnostics);
+  const { addViolation } = useDevToolbar();
+  const runDiagnostics = react.useCallback(async () => {
+    if (!address)
+      return;
+    setIsQuerying(true);
+    const newIssues = [];
+    const updatedItems = [...items];
+    for (let i = 0; i < updatedItems.length; i++) {
+      const item = updatedItems[i];
+      const context = {
+        impersonatedAddress: isImpersonating ? impersonatedAddress : address,
+        realAddress,
+        component: item.component,
+        observedValue: item.observedValue,
+        onChainValue: item.onChainValue,
+        indexedValue: item.indexedValue,
+        dataSource: item.dataSource
+      };
+      try {
+        const result = await validateLens(context, item.zone);
+        if (result.valid) {
+          updatedItems[i] = { ...item, status: "verified" };
+        } else {
+          updatedItems[i] = { ...item, status: "mismatch" };
+          newIssues.push(...result.issues);
+          result.issues.forEach((issue) => {
+            addViolation({
+              id: `${item.id}-${issue.type}`,
+              timestamp: Date.now(),
+              type: "behavioral",
+              severity: issue.severity,
+              message: issue.message,
+              element: issue.component,
+              suggestion: issue.suggestion
+            });
+          });
+        }
+      } catch {
+        updatedItems[i] = { ...item, status: "unknown" };
+      }
+    }
+    setItems(updatedItems);
+    setQuestions(generateQuestions(newIssues));
+    setIsQuerying(false);
+    if (onDiagnosisComplete) {
+      onDiagnosisComplete({
+        verified: updatedItems.filter((i) => i.status === "verified"),
+        issues: newIssues
+      });
+    }
+  }, [address, items, isImpersonating, impersonatedAddress, realAddress, validateLens, addViolation, onDiagnosisComplete]);
+  react.useEffect(() => {
+    if (autoQuery && address && items.length > 0) {
+      runDiagnostics();
+    }
+  }, [autoQuery, address]);
+  const verifiedItems = items.filter((i) => i.status === "verified");
+  const attentionItems = items.filter((i) => i.status === "mismatch" || i.status === "unknown");
+  const pendingItems = items.filter((i) => i.status === "pending");
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "sigil-diagnostic-panel", children: [
+    /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "sigil-diagnostic-header", children: [
+      /* @__PURE__ */ jsxRuntime.jsx("h3", { children: "Diagnostics" }),
+      isImpersonating && /* @__PURE__ */ jsxRuntime.jsxs("span", { className: "sigil-diagnostic-lens-badge", children: [
+        "Lens Active: ",
+        impersonatedAddress?.slice(0, 6),
+        "...",
+        impersonatedAddress?.slice(-4)
+      ] })
+    ] }),
+    error && /* @__PURE__ */ jsxRuntime.jsx("div", { className: "sigil-diagnostic-error", children: error }),
+    /* @__PURE__ */ jsxRuntime.jsx("div", { className: "sigil-diagnostic-actions", children: /* @__PURE__ */ jsxRuntime.jsx(
+      "button",
+      {
+        onClick: runDiagnostics,
+        disabled: isLoading || isQuerying || items.length === 0,
+        className: "sigil-diagnostic-query-btn",
+        children: isQuerying ? "Querying..." : "Run Diagnostics"
+      }
+    ) }),
+    verifiedItems.length > 0 && /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "sigil-diagnostic-section sigil-diagnostic-verified", children: [
+      /* @__PURE__ */ jsxRuntime.jsxs("h4", { children: [
+        "\u2713 Verified (",
+        verifiedItems.length,
+        ")"
+      ] }),
+      /* @__PURE__ */ jsxRuntime.jsx("ul", { children: verifiedItems.map((item) => /* @__PURE__ */ jsxRuntime.jsxs("li", { className: "sigil-diagnostic-item verified", children: [
+        /* @__PURE__ */ jsxRuntime.jsx("span", { className: "sigil-diagnostic-label", children: item.label }),
+        /* @__PURE__ */ jsxRuntime.jsx("span", { className: "sigil-diagnostic-value", children: item.observedValue }),
+        /* @__PURE__ */ jsxRuntime.jsx("span", { className: "sigil-diagnostic-source", children: item.dataSource })
+      ] }, item.id)) })
+    ] }),
+    attentionItems.length > 0 && /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "sigil-diagnostic-section sigil-diagnostic-attention", children: [
+      /* @__PURE__ */ jsxRuntime.jsxs("h4", { children: [
+        "\u26A0 Needs Attention (",
+        attentionItems.length,
+        ")"
+      ] }),
+      /* @__PURE__ */ jsxRuntime.jsx("ul", { children: attentionItems.map((item) => /* @__PURE__ */ jsxRuntime.jsxs("li", { className: "sigil-diagnostic-item attention", children: [
+        /* @__PURE__ */ jsxRuntime.jsx("span", { className: "sigil-diagnostic-label", children: item.label }),
+        /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "sigil-diagnostic-comparison", children: [
+          /* @__PURE__ */ jsxRuntime.jsxs("span", { className: "sigil-diagnostic-observed", children: [
+            "UI: ",
+            item.observedValue
+          ] }),
+          item.onChainValue && /* @__PURE__ */ jsxRuntime.jsxs("span", { className: "sigil-diagnostic-onchain", children: [
+            "On-chain: ",
+            item.onChainValue
+          ] }),
+          item.indexedValue && /* @__PURE__ */ jsxRuntime.jsxs("span", { className: "sigil-diagnostic-indexed", children: [
+            "Indexed: ",
+            item.indexedValue
+          ] })
+        ] })
+      ] }, item.id)) })
+    ] }),
+    pendingItems.length > 0 && /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "sigil-diagnostic-section sigil-diagnostic-pending", children: [
+      /* @__PURE__ */ jsxRuntime.jsxs("h4", { children: [
+        "\u25CB Pending (",
+        pendingItems.length,
+        ")"
+      ] }),
+      /* @__PURE__ */ jsxRuntime.jsx("ul", { children: pendingItems.map((item) => /* @__PURE__ */ jsxRuntime.jsxs("li", { className: "sigil-diagnostic-item pending", children: [
+        /* @__PURE__ */ jsxRuntime.jsx("span", { className: "sigil-diagnostic-label", children: item.label }),
+        /* @__PURE__ */ jsxRuntime.jsx("span", { className: "sigil-diagnostic-value", children: item.observedValue })
+      ] }, item.id)) })
+    ] }),
+    questions.length > 0 && /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "sigil-diagnostic-section sigil-diagnostic-questions", children: [
+      /* @__PURE__ */ jsxRuntime.jsx("h4", { children: "Questions for User" }),
+      /* @__PURE__ */ jsxRuntime.jsx("ul", { children: questions.map((q) => /* @__PURE__ */ jsxRuntime.jsxs("li", { className: `sigil-diagnostic-question ${q.severity}`, children: [
+        /* @__PURE__ */ jsxRuntime.jsx("span", { className: "sigil-diagnostic-question-text", children: q.question }),
+        q.context && /* @__PURE__ */ jsxRuntime.jsxs("span", { className: "sigil-diagnostic-question-context", children: [
+          "Suggestion: ",
+          q.context
+        ] })
+      ] }, q.id)) })
+    ] }),
+    diagnosticsState.violations.length > 0 && /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "sigil-diagnostic-section sigil-diagnostic-violations", children: [
+      /* @__PURE__ */ jsxRuntime.jsxs("h4", { children: [
+        "Recent Violations (",
+        diagnosticsState.violations.length,
+        ")"
+      ] }),
+      /* @__PURE__ */ jsxRuntime.jsx("ul", { children: diagnosticsState.violations.slice(0, 5).map((v) => /* @__PURE__ */ jsxRuntime.jsxs("li", { className: `sigil-diagnostic-violation ${v.severity}`, children: [
+        /* @__PURE__ */ jsxRuntime.jsx("span", { className: "sigil-diagnostic-violation-msg", children: v.message }),
+        v.suggestion && /* @__PURE__ */ jsxRuntime.jsxs("span", { className: "sigil-diagnostic-violation-suggestion", children: [
+          "\u2192 ",
+          v.suggestion
+        ] })
+      ] }, v.id)) })
+    ] }),
+    items.length === 0 && /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "sigil-diagnostic-empty", children: [
+      /* @__PURE__ */ jsxRuntime.jsx("p", { children: "No items to diagnose." }),
+      /* @__PURE__ */ jsxRuntime.jsx("p", { children: "Add diagnostic items to validate on-chain state." })
+    ] })
+  ] });
+}
+function useDiagnosticItems() {
+  const [items, setItems] = react.useState([]);
+  const addItem = react.useCallback((item) => {
+    setItems((prev) => [
+      ...prev,
+      {
+        ...item,
+        id: `diag-${Date.now()}-${Math.random().toString(36).slice(2, 7)}`,
+        status: "pending"
+      }
+    ]);
+  }, []);
+  const removeItem = react.useCallback((id) => {
+    setItems((prev) => prev.filter((i) => i.id !== id));
+  }, []);
+  const clearItems = react.useCallback(() => {
+    setItems([]);
+  }, []);
+  const updateItem = react.useCallback((id, updates) => {
+    setItems(
+      (prev) => prev.map((i) => i.id === id ? { ...i, ...updates } : i)
+    );
+  }, []);
+  return {
+    items,
+    addItem,
+    removeItem,
+    clearItems,
+    updateItem
+  };
+}
+function formatEther(wei, decimals = 4) {
+  const ethString = (Number(wei) / 1e18).toFixed(decimals);
+  return `${ethString} ETH`;
+}
+function formatGas(gas) {
+  if (gas >= 1000000n) {
+    return `${(Number(gas) / 1e6).toFixed(2)}M`;
+  }
+  if (gas >= 1000n) {
+    return `${(Number(gas) / 1e3).toFixed(1)}K`;
+  }
+  return gas.toString();
+}
+function truncateAddress2(address) {
+  return `${address.slice(0, 6)}...${address.slice(-4)}`;
+}
+function formatBalanceChange(change) {
+  const sign = change.delta >= 0n ? "+" : "";
+  return `${sign}${formatEther(change.delta)}`;
+}
+function estimateUSD(wei, ethPrice = 2e3) {
+  const eth = Number(wei) / 1e18;
+  const usd = eth * ethPrice;
+  return `~$${usd.toFixed(2)}`;
+}
+function BalanceChangesSection({ changes }) {
+  if (changes.length === 0)
+    return null;
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "sigil-simulation-section sigil-simulation-balances", children: [
+    /* @__PURE__ */ jsxRuntime.jsx("h4", { children: "Balance Changes" }),
+    /* @__PURE__ */ jsxRuntime.jsx("ul", { children: changes.map((change, i) => /* @__PURE__ */ jsxRuntime.jsxs("li", { className: "sigil-simulation-balance-item", children: [
+      /* @__PURE__ */ jsxRuntime.jsx("span", { className: "sigil-simulation-address", title: change.address, children: truncateAddress2(change.address) }),
+      /* @__PURE__ */ jsxRuntime.jsx("span", { className: `sigil-simulation-delta ${change.delta >= 0n ? "positive" : "negative"}`, children: formatBalanceChange(change) }),
+      /* @__PURE__ */ jsxRuntime.jsx("span", { className: "sigil-simulation-token", children: change.symbol ?? (change.token ? truncateAddress2(change.token) : "ETH") })
+    ] }, i)) })
+  ] });
+}
+function EventLogsSection({ logs, showDecoded }) {
+  if (logs.length === 0)
+    return null;
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "sigil-simulation-section sigil-simulation-logs", children: [
+    /* @__PURE__ */ jsxRuntime.jsxs("h4", { children: [
+      "Event Logs (",
+      logs.length,
+      ")"
+    ] }),
+    /* @__PURE__ */ jsxRuntime.jsxs("ul", { children: [
+      logs.slice(0, 10).map((log, i) => /* @__PURE__ */ jsxRuntime.jsxs("li", { className: "sigil-simulation-log-item", children: [
+        /* @__PURE__ */ jsxRuntime.jsx("span", { className: "sigil-simulation-address", title: log.address, children: truncateAddress2(log.address) }),
+        showDecoded && log.eventName ? /* @__PURE__ */ jsxRuntime.jsx("span", { className: "sigil-simulation-event-name", children: log.eventName }) : /* @__PURE__ */ jsxRuntime.jsxs("span", { className: "sigil-simulation-topic", title: log.topics[0], children: [
+          log.topics[0]?.slice(0, 10),
+          "..."
+        ] })
+      ] }, i)),
+      logs.length > 10 && /* @__PURE__ */ jsxRuntime.jsxs("li", { className: "sigil-simulation-more", children: [
+        "+",
+        logs.length - 10,
+        " more events"
+      ] })
+    ] })
+  ] });
+}
+function GasSummarySection({
+  result,
+  ethPrice
+}) {
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "sigil-simulation-section sigil-simulation-gas", children: [
+    /* @__PURE__ */ jsxRuntime.jsx("h4", { children: "Gas" }),
+    /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "sigil-simulation-gas-grid", children: [
+      /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "sigil-simulation-gas-item", children: [
+        /* @__PURE__ */ jsxRuntime.jsx("span", { className: "sigil-simulation-label", children: "Used" }),
+        /* @__PURE__ */ jsxRuntime.jsx("span", { className: "sigil-simulation-value", children: formatGas(result.gasUsed) })
+      ] }),
+      /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "sigil-simulation-gas-item", children: [
+        /* @__PURE__ */ jsxRuntime.jsx("span", { className: "sigil-simulation-label", children: "Limit" }),
+        /* @__PURE__ */ jsxRuntime.jsx("span", { className: "sigil-simulation-value", children: formatGas(result.gasLimit) })
+      ] }),
+      /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "sigil-simulation-gas-item", children: [
+        /* @__PURE__ */ jsxRuntime.jsx("span", { className: "sigil-simulation-label", children: "Price" }),
+        /* @__PURE__ */ jsxRuntime.jsxs("span", { className: "sigil-simulation-value", children: [
+          (Number(result.effectiveGasPrice) / 1e9).toFixed(2),
+          " gwei"
+        ] })
+      ] }),
+      /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "sigil-simulation-gas-item sigil-simulation-gas-total", children: [
+        /* @__PURE__ */ jsxRuntime.jsx("span", { className: "sigil-simulation-label", children: "Total Cost" }),
+        /* @__PURE__ */ jsxRuntime.jsxs("span", { className: "sigil-simulation-value", children: [
+          formatEther(result.totalCost),
+          /* @__PURE__ */ jsxRuntime.jsx("span", { className: "sigil-simulation-usd", children: estimateUSD(result.totalCost, ethPrice) })
+        ] })
+      ] })
+    ] })
+  ] });
+}
+function SimulationResultDisplay({
+  result,
+  ethPrice,
+  showDecodedLogs
+}) {
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: `sigil-simulation-result ${result.success ? "success" : "failure"}`, children: [
+    /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "sigil-simulation-status", children: [
+      /* @__PURE__ */ jsxRuntime.jsx("span", { className: "sigil-simulation-status-icon", children: result.success ? "\u2713" : "\u2717" }),
+      /* @__PURE__ */ jsxRuntime.jsx("span", { className: "sigil-simulation-status-text", children: result.success ? "Transaction Successful" : "Transaction Failed" })
+    ] }),
+    !result.success && result.revertReason && /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "sigil-simulation-revert", children: [
+      /* @__PURE__ */ jsxRuntime.jsx("h4", { children: "Revert Reason" }),
+      /* @__PURE__ */ jsxRuntime.jsx("pre", { className: "sigil-simulation-revert-message", children: result.revertReason })
+    ] }),
+    /* @__PURE__ */ jsxRuntime.jsx(GasSummarySection, { result, ethPrice }),
+    /* @__PURE__ */ jsxRuntime.jsx(BalanceChangesSection, { changes: result.balanceChanges }),
+    /* @__PURE__ */ jsxRuntime.jsx(EventLogsSection, { logs: result.logs, showDecoded: showDecodedLogs }),
+    /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "sigil-simulation-section sigil-simulation-meta", children: [
+      /* @__PURE__ */ jsxRuntime.jsxs("span", { className: "sigil-simulation-block", children: [
+        "Block: ",
+        result.blockNumber.toString()
+      ] }),
+      /* @__PURE__ */ jsxRuntime.jsx("span", { className: "sigil-simulation-time", children: new Date(result.timestamp).toLocaleTimeString() })
+    ] })
+  ] });
+}
+function TransactionInputForm({
+  onSimulate,
+  isSimulating
+}) {
+  const [from, setFrom] = react.useState("");
+  const [to, setTo] = react.useState("");
+  const [value, setValue] = react.useState("");
+  const [data, setData] = react.useState("");
+  const handleSubmit = react.useCallback(
+    (e) => {
+      e.preventDefault();
+      if (!from || !to)
+        return;
+      const tx = {
+        from,
+        to,
+        value: value ? BigInt(value) : void 0,
+        data: data ? data : void 0
+      };
+      onSimulate(tx);
+    },
+    [from, to, value, data, onSimulate]
+  );
+  return /* @__PURE__ */ jsxRuntime.jsxs("form", { onSubmit: handleSubmit, className: "sigil-simulation-form", children: [
+    /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "sigil-simulation-field", children: [
+      /* @__PURE__ */ jsxRuntime.jsx("label", { htmlFor: "sim-from", children: "From" }),
+      /* @__PURE__ */ jsxRuntime.jsx(
+        "input",
+        {
+          id: "sim-from",
+          type: "text",
+          value: from,
+          onChange: (e) => setFrom(e.target.value),
+          placeholder: "0x...",
+          disabled: isSimulating
+        }
+      )
+    ] }),
+    /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "sigil-simulation-field", children: [
+      /* @__PURE__ */ jsxRuntime.jsx("label", { htmlFor: "sim-to", children: "To" }),
+      /* @__PURE__ */ jsxRuntime.jsx(
+        "input",
+        {
+          id: "sim-to",
+          type: "text",
+          value: to,
+          onChange: (e) => setTo(e.target.value),
+          placeholder: "0x...",
+          disabled: isSimulating
+        }
+      )
+    ] }),
+    /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "sigil-simulation-field", children: [
+      /* @__PURE__ */ jsxRuntime.jsx("label", { htmlFor: "sim-value", children: "Value (wei)" }),
+      /* @__PURE__ */ jsxRuntime.jsx(
+        "input",
+        {
+          id: "sim-value",
+          type: "text",
+          value,
+          onChange: (e) => setValue(e.target.value),
+          placeholder: "0",
+          disabled: isSimulating
+        }
+      )
+    ] }),
+    /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "sigil-simulation-field", children: [
+      /* @__PURE__ */ jsxRuntime.jsx("label", { htmlFor: "sim-data", children: "Data" }),
+      /* @__PURE__ */ jsxRuntime.jsx(
+        "input",
+        {
+          id: "sim-data",
+          type: "text",
+          value: data,
+          onChange: (e) => setData(e.target.value),
+          placeholder: "0x...",
+          disabled: isSimulating
+        }
+      )
+    ] }),
+    /* @__PURE__ */ jsxRuntime.jsx(
+      "button",
+      {
+        type: "submit",
+        disabled: isSimulating || !from || !to,
+        className: "sigil-simulation-submit",
+        children: isSimulating ? "Simulating..." : "Simulate"
+      }
+    )
+  ] });
+}
+function SimulationPanel({
+  onSimulate,
+  result,
+  isSimulating = false,
+  error,
+  ethPrice = 2e3,
+  showDecodedLogs = true
+}) {
+  const handleSimulate = react.useCallback(
+    async (tx) => {
+      if (onSimulate) {
+        await onSimulate(tx);
+      }
+    },
+    [onSimulate]
+  );
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "sigil-simulation-panel", children: [
+    /* @__PURE__ */ jsxRuntime.jsx("div", { className: "sigil-simulation-header", children: /* @__PURE__ */ jsxRuntime.jsx("h3", { children: "Transaction Simulation" }) }),
+    onSimulate && /* @__PURE__ */ jsxRuntime.jsx(
+      TransactionInputForm,
+      {
+        onSimulate: handleSimulate,
+        isSimulating
+      }
+    ),
+    error && /* @__PURE__ */ jsxRuntime.jsx("div", { className: "sigil-simulation-error", children: error }),
+    isSimulating && !result && /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "sigil-simulation-loading", children: [
+      /* @__PURE__ */ jsxRuntime.jsx("span", { className: "sigil-simulation-spinner" }),
+      /* @__PURE__ */ jsxRuntime.jsx("span", { children: "Running simulation..." })
+    ] }),
+    result && /* @__PURE__ */ jsxRuntime.jsx(
+      SimulationResultDisplay,
+      {
+        result,
+        ethPrice,
+        showDecodedLogs
+      }
+    ),
+    !result && !isSimulating && !error && /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "sigil-simulation-empty", children: [
+      /* @__PURE__ */ jsxRuntime.jsx("p", { children: "No simulation results yet." }),
+      /* @__PURE__ */ jsxRuntime.jsx("p", { children: "Enter transaction details above to simulate." })
+    ] })
+  ] });
+}
+function formatValue(value) {
+  if (value === void 0)
+    return "undefined";
+  if (value === null)
+    return "null";
+  if (typeof value === "bigint")
+    return `${value.toString()}n`;
+  if (typeof value === "object") {
+    try {
+      return JSON.stringify(value, null, 2);
+    } catch {
+      return "[Object]";
+    }
+  }
+  return String(value);
+}
+function valuesEqual(a, b) {
+  if (a === b)
+    return true;
+  if (typeof a === "bigint" && typeof b === "bigint")
+    return a === b;
+  if (typeof a === "object" && typeof b === "object") {
+    try {
+      return JSON.stringify(a) === JSON.stringify(b);
+    } catch {
+      return false;
+    }
+  }
+  return false;
+}
+function getSourceColor(source) {
+  switch (source) {
+    case "on-chain":
+      return "sigil-source-onchain";
+    case "indexed":
+      return "sigil-source-indexed";
+    case "cache":
+      return "sigil-source-cache";
+    case "local":
+      return "sigil-source-local";
+    default:
+      return "sigil-source-unknown";
+  }
+}
+function getChangeColor(type) {
+  switch (type) {
+    case "added":
+      return "sigil-change-added";
+    case "removed":
+      return "sigil-change-removed";
+    case "modified":
+      return "sigil-change-modified";
+    default:
+      return "sigil-change-unchanged";
+  }
+}
+function ComparisonRow({ item }) {
+  const [expanded, setExpanded] = react.useState(false);
+  const leftValue = item.left ? formatValue(item.left.value) : "\u2014";
+  const rightValue = item.right ? formatValue(item.right.value) : "\u2014";
+  const isLongValue = leftValue.length > 50 || rightValue.length > 50;
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: `sigil-comparison-row ${item.isDifferent ? "different" : ""}`, children: [
+    /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "sigil-comparison-path", children: [
+      /* @__PURE__ */ jsxRuntime.jsx("code", { children: item.path }),
+      /* @__PURE__ */ jsxRuntime.jsx("span", { className: `sigil-comparison-badge ${getChangeColor(item.changeType)}`, children: item.changeType })
+    ] }),
+    /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "sigil-comparison-values", children: [
+      /* @__PURE__ */ jsxRuntime.jsx("div", { className: "sigil-comparison-value sigil-comparison-left", children: item.left ? /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+        /* @__PURE__ */ jsxRuntime.jsx("span", { className: `sigil-comparison-source ${getSourceColor(item.left.source)}`, children: item.left.source }),
+        isLongValue ? /* @__PURE__ */ jsxRuntime.jsx(
+          "button",
+          {
+            className: "sigil-comparison-expand",
+            onClick: () => setExpanded(!expanded),
+            children: expanded ? "Collapse" : "Expand"
+          }
+        ) : /* @__PURE__ */ jsxRuntime.jsx("code", { className: "sigil-comparison-value-text", children: leftValue })
+      ] }) : /* @__PURE__ */ jsxRuntime.jsx("span", { className: "sigil-comparison-empty", children: "\u2014" }) }),
+      /* @__PURE__ */ jsxRuntime.jsx("div", { className: "sigil-comparison-value sigil-comparison-right", children: item.right ? /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+        /* @__PURE__ */ jsxRuntime.jsx("span", { className: `sigil-comparison-source ${getSourceColor(item.right.source)}`, children: item.right.source }),
+        isLongValue ? /* @__PURE__ */ jsxRuntime.jsx(
+          "button",
+          {
+            className: "sigil-comparison-expand",
+            onClick: () => setExpanded(!expanded),
+            children: expanded ? "Collapse" : "Expand"
+          }
+        ) : /* @__PURE__ */ jsxRuntime.jsx("code", { className: "sigil-comparison-value-text", children: rightValue })
+      ] }) : /* @__PURE__ */ jsxRuntime.jsx("span", { className: "sigil-comparison-empty", children: "\u2014" }) })
+    ] }),
+    expanded && isLongValue && /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "sigil-comparison-expanded", children: [
+      /* @__PURE__ */ jsxRuntime.jsx("div", { className: "sigil-comparison-expanded-left", children: /* @__PURE__ */ jsxRuntime.jsx("pre", { children: leftValue }) }),
+      /* @__PURE__ */ jsxRuntime.jsx("div", { className: "sigil-comparison-expanded-right", children: /* @__PURE__ */ jsxRuntime.jsx("pre", { children: rightValue }) })
+    ] })
+  ] });
+}
+function StateComparison({
+  leftSnapshot,
+  rightSnapshot,
+  leftLabel = "Before",
+  rightLabel = "After",
+  showOnlyDifferences = false,
+  filterSource = null,
+  onExport
+}) {
+  const [filter, setFilter] = react.useState("");
+  const [onlyDiff, setOnlyDiff] = react.useState(showOnlyDifferences);
+  const [sourceFilter, setSourceFilter] = react.useState(filterSource);
+  const comparisonItems = react.useMemo(() => {
+    const items = [];
+    const allPaths = /* @__PURE__ */ new Set();
+    if (leftSnapshot) {
+      Object.keys(leftSnapshot.values).forEach((path) => allPaths.add(path));
+    }
+    if (rightSnapshot) {
+      Object.keys(rightSnapshot.values).forEach((path) => allPaths.add(path));
+    }
+    for (const path of allPaths) {
+      const left = leftSnapshot?.values[path];
+      const right = rightSnapshot?.values[path];
+      let changeType = "unchanged";
+      let isDifferent = false;
+      if (left && !right) {
+        changeType = "removed";
+        isDifferent = true;
+      } else if (!left && right) {
+        changeType = "added";
+        isDifferent = true;
+      } else if (left && right && !valuesEqual(left.value, right.value)) {
+        changeType = "modified";
+        isDifferent = true;
+      }
+      items.push({
+        path,
+        left,
+        right,
+        isDifferent,
+        changeType
+      });
+    }
+    items.sort((a, b) => a.path.localeCompare(b.path));
+    return items;
+  }, [leftSnapshot, rightSnapshot]);
+  const filteredItems = react.useMemo(() => {
+    return comparisonItems.filter((item) => {
+      if (filter && !item.path.toLowerCase().includes(filter.toLowerCase())) {
+        return false;
+      }
+      if (onlyDiff && !item.isDifferent) {
+        return false;
+      }
+      if (sourceFilter) {
+        const leftMatch = item.left?.source === sourceFilter;
+        const rightMatch = item.right?.source === sourceFilter;
+        if (!leftMatch && !rightMatch) {
+          return false;
+        }
+      }
+      return true;
+    });
+  }, [comparisonItems, filter, onlyDiff, sourceFilter]);
+  const stats = react.useMemo(() => {
+    const added = comparisonItems.filter((i) => i.changeType === "added").length;
+    const removed = comparisonItems.filter((i) => i.changeType === "removed").length;
+    const modified = comparisonItems.filter((i) => i.changeType === "modified").length;
+    const unchanged = comparisonItems.filter((i) => i.changeType === "unchanged").length;
+    return { added, removed, modified, unchanged, total: comparisonItems.length };
+  }, [comparisonItems]);
+  const handleExport = react.useCallback(() => {
+    if (onExport) {
+      onExport(filteredItems);
+    } else {
+      const blob = new Blob([JSON.stringify(filteredItems, null, 2)], {
+        type: "application/json"
+      });
+      const url = URL.createObjectURL(blob);
+      const a = document.createElement("a");
+      a.href = url;
+      a.download = `state-comparison-${Date.now()}.json`;
+      a.click();
+      URL.revokeObjectURL(url);
+    }
+  }, [filteredItems, onExport]);
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "sigil-state-comparison", children: [
+    /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "sigil-comparison-header", children: [
+      /* @__PURE__ */ jsxRuntime.jsx("h3", { children: "State Comparison" }),
+      /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "sigil-comparison-stats", children: [
+        /* @__PURE__ */ jsxRuntime.jsxs("span", { className: "sigil-stat sigil-stat-added", children: [
+          "+",
+          stats.added
+        ] }),
+        /* @__PURE__ */ jsxRuntime.jsxs("span", { className: "sigil-stat sigil-stat-removed", children: [
+          "-",
+          stats.removed
+        ] }),
+        /* @__PURE__ */ jsxRuntime.jsxs("span", { className: "sigil-stat sigil-stat-modified", children: [
+          "~",
+          stats.modified
+        ] }),
+        /* @__PURE__ */ jsxRuntime.jsxs("span", { className: "sigil-stat sigil-stat-unchanged", children: [
+          "=",
+          stats.unchanged
+        ] })
+      ] })
+    ] }),
+    /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "sigil-comparison-snapshots", children: [
+      /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "sigil-comparison-snapshot-left", children: [
+        /* @__PURE__ */ jsxRuntime.jsx("span", { className: "sigil-comparison-label", children: leftLabel }),
+        leftSnapshot && /* @__PURE__ */ jsxRuntime.jsx("span", { className: "sigil-comparison-time", children: new Date(leftSnapshot.timestamp).toLocaleTimeString() })
+      ] }),
+      /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "sigil-comparison-snapshot-right", children: [
+        /* @__PURE__ */ jsxRuntime.jsx("span", { className: "sigil-comparison-label", children: rightLabel }),
+        rightSnapshot && /* @__PURE__ */ jsxRuntime.jsx("span", { className: "sigil-comparison-time", children: new Date(rightSnapshot.timestamp).toLocaleTimeString() })
+      ] })
+    ] }),
+    /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "sigil-comparison-filters", children: [
+      /* @__PURE__ */ jsxRuntime.jsx(
+        "input",
+        {
+          type: "text",
+          value: filter,
+          onChange: (e) => setFilter(e.target.value),
+          placeholder: "Filter by path...",
+          className: "sigil-comparison-filter-input"
+        }
+      ),
+      /* @__PURE__ */ jsxRuntime.jsxs("label", { className: "sigil-comparison-filter-checkbox", children: [
+        /* @__PURE__ */ jsxRuntime.jsx(
+          "input",
+          {
+            type: "checkbox",
+            checked: onlyDiff,
+            onChange: (e) => setOnlyDiff(e.target.checked)
+          }
+        ),
+        "Only differences"
+      ] }),
+      /* @__PURE__ */ jsxRuntime.jsxs(
+        "select",
+        {
+          value: sourceFilter ?? "",
+          onChange: (e) => setSourceFilter(e.target.value || null),
+          className: "sigil-comparison-filter-select",
+          children: [
+            /* @__PURE__ */ jsxRuntime.jsx("option", { value: "", children: "All sources" }),
+            /* @__PURE__ */ jsxRuntime.jsx("option", { value: "on-chain", children: "On-chain" }),
+            /* @__PURE__ */ jsxRuntime.jsx("option", { value: "indexed", children: "Indexed" }),
+            /* @__PURE__ */ jsxRuntime.jsx("option", { value: "cache", children: "Cache" }),
+            /* @__PURE__ */ jsxRuntime.jsx("option", { value: "local", children: "Local" })
+          ]
+        }
+      ),
+      /* @__PURE__ */ jsxRuntime.jsx("button", { onClick: handleExport, className: "sigil-comparison-export", children: "Export JSON" })
+    ] }),
+    /* @__PURE__ */ jsxRuntime.jsx("div", { className: "sigil-comparison-items", children: filteredItems.length === 0 ? /* @__PURE__ */ jsxRuntime.jsx("div", { className: "sigil-comparison-empty-state", children: comparisonItems.length === 0 ? "No state to compare. Capture snapshots first." : "No items match the current filters." }) : filteredItems.map((item) => /* @__PURE__ */ jsxRuntime.jsx(ComparisonRow, { item }, item.path)) })
+  ] });
+}
+function useStateSnapshots() {
+  const [snapshots, setSnapshots] = react.useState([]);
+  const [leftId, setLeftId] = react.useState(null);
+  const [rightId, setRightId] = react.useState(null);
+  const captureSnapshot = react.useCallback((label, values) => {
+    const snapshot = {
+      id: `snap-${Date.now()}-${Math.random().toString(36).slice(2, 7)}`,
+      label,
+      timestamp: Date.now(),
+      values
+    };
+    setSnapshots((prev) => [...prev, snapshot]);
+    return snapshot;
+  }, []);
+  const deleteSnapshot = react.useCallback((id) => {
+    setSnapshots((prev) => prev.filter((s) => s.id !== id));
+    if (leftId === id)
+      setLeftId(null);
+    if (rightId === id)
+      setRightId(null);
+  }, [leftId, rightId]);
+  const clearSnapshots = react.useCallback(() => {
+    setSnapshots([]);
+    setLeftId(null);
+    setRightId(null);
+  }, []);
+  const leftSnapshot = snapshots.find((s) => s.id === leftId) ?? null;
+  const rightSnapshot = snapshots.find((s) => s.id === rightId) ?? null;
+  return {
+    snapshots,
+    leftSnapshot,
+    rightSnapshot,
+    leftId,
+    rightId,
+    setLeftId,
+    setRightId,
+    captureSnapshot,
+    deleteSnapshot,
+    clearSnapshots
+  };
+}
+
+exports.DevToolbar = DevToolbar;
+exports.DevToolbarProvider = DevToolbarProvider;
+exports.DevToolbarTrigger = DevToolbarTrigger;
+exports.DevToolbarWithTrigger = DevToolbarWithTrigger;
+exports.DiagnosticPanel = DiagnosticPanel;
+exports.IPCClient = IPCClient;
+exports.LensActiveBadge = LensActiveBadge;
+exports.LocalStorageTransport = LocalStorageTransport;
+exports.MockTransport = MockTransport;
+exports.SimulationPanel = SimulationPanel;
+exports.StateComparison = StateComparison;
+exports.UserLens = UserLens;
+exports.createAnvilForkService = createAnvilForkService;
+exports.createForkService = createForkService;
+exports.createSimulationService = createSimulationService;
+exports.createTenderlyForkService = createTenderlyForkService;
+exports.getForkService = getForkService;
+exports.getIPCClient = getIPCClient;
+exports.getSimulationService = getSimulationService;
+exports.resetForkService = resetForkService;
+exports.resetIPCClient = resetIPCClient;
+exports.resetSimulationService = resetSimulationService;
+exports.useDevToolbar = useDevToolbar;
+exports.useDevToolbarConfig = useDevToolbarConfig;
+exports.useDevToolbarSelector = useDevToolbarSelector;
+exports.useDiagnosticItems = useDiagnosticItems;
+exports.useForkState = useForkState;
+exports.useIPCClient = useIPCClient;
+exports.useImpersonatedAddress = useImpersonatedAddress;
+exports.useIsImpersonating = useIsImpersonating;
+exports.useLensAwareAccount = useLensAwareAccount;
+exports.useSavedAddresses = useSavedAddresses;
+exports.useSimulation = useSimulation;
+exports.useStateSnapshots = useStateSnapshots;
+exports.useTransactionSimulation = useTransactionSimulation;
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=index.cjs.map