@hardkas/react 0.5.5-alpha → 0.6.1-alpha

package/dist/index.d.ts

@@ -25,6 +25,7 @@ interface HardKasReactConfig {
     readonly devServerUrl?: string;
 }
 type SSEStatus = "connecting" | "connected" | "disconnected" | "reconnecting" | "failed";
+type ProjectionStatus = "synced" | "stale" | "syncing";
 interface RuntimeEvent {
     type: string;
     payload?: any;
@@ -36,6 +37,10 @@ interface HardKasContextValue {
     readonly igraClient: PublicClient;
     readonly queryClient: QueryClient;
     readonly sseStatus: SSEStatus;
+    readonly projectionStatus: ProjectionStatus;
+    readonly generationId: string | null;
+    readonly lastSyncedAt: string | null;
+    readonly apiFetch: (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
     readonly lastEvent: RuntimeEvent | null;
     readonly subscribe: (callback: EventCallback) => () => void;
     readonly providers: EIP6963ProviderDetail[];
@@ -123,26 +128,25 @@ declare function useIgraBalance(options?: {
     refetchInterval?: number;
 }): _tanstack_react_query.UseQueryResult<bigint, Error>;
 
-/**
- * WARNING: ALPHA-ONLY LOCAL-RUNTIME COUPLING
- *
- * This file directly imports `@hardkas/bridge-local` to perform local bridge simulation.
- * This puts local simulation logic and heavy CPU simulation directly into the React package,
- * meaning it is NOT browser-production safe without polyfills or is intended exclusively
- * for the local developer preview context.
- *
- * TODO: In a future release, decouple this simulation code from the core `@hardkas/react` library.
- * The hooks should ideally make dev-server REST/SSE HTTP calls, or be extracted into a separate
- * package `@hardkas/react-local` to maintain clean, production-safe boundaries.
- */
-declare function useBridgeLocalPlan(options: {
-    amountSompi: bigint;
-    toIgra?: string;
-} | null): _tanstack_react_query.UseQueryResult<any, Error>;
-declare function useBridgeLocalSimulation(): _tanstack_react_query.UseMutationResult<any, Error, {
-    payloadBase: any;
-    prefix: string;
-}, unknown>;
+interface HardKasEventInfo {
+    eventId: string;
+    kind: string;
+    domain: string;
+    workflowId: string;
+    correlationId: string;
+    causationId: string | null;
+    txId: string | null;
+    artifactId: string | null;
+    networkId: string;
+    timestamp: string | null;
+    payload: any;
+}
+interface UseEventsResponse {
+    events: HardKasEventInfo[];
+    observabilityDrift?: boolean;
+    reason?: string;
+}
+declare function useEvents(kind?: string, txId?: string): _tanstack_react_query.UseQueryResult<UseEventsResponse, Error>;
 
 type CcipRequestReturnType = Hex;
 
@@ -4748,4 +4752,159 @@ declare function useIgraWriteContract(): _tanstack_react_query.UseMutationResult
 }, unknown>;
 declare function useIgraWaitForReceipt(): _tanstack_react_query.UseMutationResult<viem.TransactionReceipt, Error, `0x${string}`, unknown>;
 
-export { type EventCallback, type HardKasContextValue, HardKasProvider, type HardKasReactConfig, type HealthInfo, type KasWareLocalState, type KasWareSessionMatch, type MetaMaskLocalState, type RuntimeEvent, type SSEStatus, type SandboxConnection, type SessionInfo, useBridgeLocalPlan, useBridgeLocalSimulation, useConnectKasWareLocal, useCreateSandboxSession, useDisconnectSandboxSession, useHardKas, useHardKasHealth, useHardKasSession, useIgraAccount, useIgraBalance, useIgraInjectedAccount, useIgraReadContract, useIgraWaitForReceipt, useIgraWallet, useIgraWriteContract, useKasWareLocal, useKasWareSessionMatch, useKaspaBalance, useKaspaWallet, useLocalIgraWalletClient, useMetaMaskLocal, usePairSandboxSession, useSandboxSessions, useSwitchToLocalIgra };
+interface OverviewStats {
+    projectName: string;
+    network: string;
+    workspaceRoot: string;
+    artifactDir: string;
+    queryStorePath: string;
+    runtimeState: "EMPTY" | "ACTIVE" | "PENDING" | "DEGRADED" | "CORRUPTED" | "VERIFIED";
+    runtimeReason: string;
+    recommendedAction: string;
+    guarantees: {
+        artifactIntegrity: "available" | "failed" | "not_checked";
+        localReplay: "verified" | "failed" | "not_checked";
+        consensusValidated: boolean;
+        networkFinality: boolean;
+    };
+    counts: {
+        artifacts: number;
+        transactions: number;
+        events: number;
+        replays: number;
+        pendingReplays: number;
+        corruptedArtifacts: number;
+        degradedProjections: number;
+    };
+}
+declare function useOverview(): _tanstack_react_query.UseQueryResult<OverviewStats | null, Error>;
+
+interface HardKasAccountInfo {
+    name: string;
+    kind: string;
+    address: string;
+    balance: string;
+    privateKeyEnv?: string;
+    walletId?: string;
+}
+interface HardKasAccountsResponse {
+    accounts: HardKasAccountInfo[];
+    provenance?: {
+        authority: string;
+        derivedFrom?: string;
+        originalPath?: string;
+        integrity: "verified" | "corrupted" | "invalid_json" | "unknown";
+        replayScope: "local-only" | "global" | "unknown";
+        consensusValidated: boolean;
+    };
+}
+declare function useAccounts(): _tanstack_react_query.UseQueryResult<HardKasAccountsResponse, Error>;
+
+interface TransactionSummary {
+    id: string;
+    txId?: string;
+    planId?: string;
+    signedId?: string;
+    status: string;
+    from: string;
+    to: string;
+    amountSompi: string;
+    amount: string;
+    feeSompi?: string;
+    timestamp: string;
+    mode: string;
+    networkId: string;
+    layer: "L1" | "L2";
+}
+interface LineageNode {
+    id: string;
+    label: string;
+    schema: string;
+}
+interface LineageEdge {
+    from: string;
+    to: string;
+    label: string;
+}
+interface TransactionDetail {
+    id: string;
+    plan: any;
+    signed: any;
+    receipt: any;
+    trace: any;
+    replay: any;
+    lineage: {
+        nodes: LineageNode[];
+        edges: LineageEdge[];
+    };
+}
+declare function useTransactions(): _tanstack_react_query.UseQueryResult<TransactionSummary[], Error>;
+declare function useTransaction(id: string): _tanstack_react_query.UseQueryResult<TransactionDetail | null, Error>;
+
+interface ArtifactSummary {
+    artifactId: string;
+    contentHash: string;
+    schema: string;
+    version: string;
+    kind: string;
+    mode: string;
+    networkId: string;
+    txId?: string;
+    createdAt: string;
+    path: string;
+}
+declare function useArtifacts(schemaFilter?: string): _tanstack_react_query.UseQueryResult<ArtifactSummary[], Error>;
+declare function useArtifact(id: string): _tanstack_react_query.UseQueryResult<any, Error>;
+
+interface ReplaySummary {
+    artifactId: string;
+    txId: string;
+    planOk: boolean;
+    receiptOk: boolean;
+    invariantsOk: boolean;
+    ok: boolean;
+    checks: {
+        workflowDeterministic: string;
+        consensusValidation: string;
+        l2BridgeCorrectness: string;
+    };
+    errors: string[];
+    divergencesCount: number;
+    createdAt: string;
+}
+interface UseReplayStatusResponse {
+    replays: ReplaySummary[];
+    pendingReplays: any[];
+    pendingReplay: boolean;
+    reason?: string;
+}
+declare function useReplayStatus(): _tanstack_react_query.UseQueryResult<UseReplayStatusResponse, Error>;
+declare function useReplayDetail(txId: string): _tanstack_react_query.UseQueryResult<any, Error>;
+
+interface DeploymentSummary {
+    artifactId: string;
+    label: string;
+    networkId: string;
+    status: string;
+    txId?: string;
+    deployedAt: string;
+    deployedAddresses: string[];
+    deployer?: string;
+    notes?: string;
+}
+declare function useDeployments(): _tanstack_react_query.UseQueryResult<DeploymentSummary[], Error>;
+
+interface ActivityEvent {
+    eventId: string;
+    kind: string;
+    domain: string;
+    workflowId: string;
+    txId?: string;
+    artifactId?: string;
+    networkId: string;
+    timestamp: string;
+    payload: any;
+}
+declare function useActivity(): _tanstack_react_query.UseQueryResult<ActivityEvent[], Error>;
+
+export { type ActivityEvent, type ArtifactSummary, type DeploymentSummary, type EventCallback, type HardKasAccountInfo, type HardKasAccountsResponse, type HardKasContextValue, type HardKasEventInfo, HardKasProvider, type HardKasReactConfig, type HealthInfo, type KasWareLocalState, type KasWareSessionMatch, type LineageEdge, type LineageNode, type MetaMaskLocalState, type OverviewStats, type ReplaySummary, type RuntimeEvent, type SSEStatus, type SandboxConnection, type SessionInfo, type TransactionDetail, type TransactionSummary, type UseEventsResponse, type UseReplayStatusResponse, useAccounts, useActivity, useArtifact, useArtifacts, useConnectKasWareLocal, useCreateSandboxSession, useDeployments, useDisconnectSandboxSession, useEvents, useHardKas, useHardKasHealth, useHardKasSession, useIgraAccount, useIgraBalance, useIgraInjectedAccount, useIgraReadContract, useIgraWaitForReceipt, useIgraWallet, useIgraWriteContract, useKasWareLocal, useKasWareSessionMatch, useKaspaBalance, useKaspaWallet, useLocalIgraWalletClient, useMetaMaskLocal, useOverview, usePairSandboxSession, useReplayDetail, useReplayStatus, useSandboxSessions, useSwitchToLocalIgra, useTransaction, useTransactions };

package/dist/index.js

@@ -2,11 +2,14 @@
 import React, { createContext, useContext, useMemo } from "react";
 import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
 import { createPublicClient, http } from "viem";
-import { jsx } from "react/jsx-runtime";
+import { jsx, jsxs } from "react/jsx-runtime";
 var HardKasContext = createContext(void 0);
 function HardKasProvider({ config, children, queryClient: externalQueryClient }) {
   const queryClient = useMemo(() => externalQueryClient ?? new QueryClient(), [externalQueryClient]);
   const [sseStatus, setSseStatus] = React.useState("disconnected");
+  const [projectionStatus, setProjectionStatus] = React.useState("synced");
+  const [generationId, setGenerationId] = React.useState(null);
+  const [lastSyncedAt, setLastSyncedAt] = React.useState(null);
   const [lastEvent, setLastEvent] = React.useState(null);
   const listeners = React.useRef(/* @__PURE__ */ new Set());
   const eventSource = React.useRef(null);
@@ -16,10 +19,58 @@ function HardKasProvider({ config, children, queryClient: externalQueryClient })
   const [activeProvider, setActiveProvider] = React.useState(null);
   const [walletAddress, setWalletAddress] = React.useState(null);
   const [walletChainId, setWalletChainId] = React.useState(null);
+  const devToken = React.useMemo(() => {
+    if (typeof window !== "undefined") {
+      if (window.__HARDKAS_DEV_TOKEN__) {
+        return window.__HARDKAS_DEV_TOKEN__;
+      }
+      const params = new URLSearchParams(window.location.search);
+      return params.get("token") || "";
+    }
+    return "";
+  }, []);
+  const [tokenMissing, setTokenMissing] = React.useState(false);
+  React.useEffect(() => {
+    if (typeof window !== "undefined") {
+      const isTest = typeof globalThis.vi !== "undefined" || window.__MOCK_SSE__ || process.env.NODE_ENV === "test";
+      const isDashboard = window.location.pathname.startsWith("/") || window.location.port === "7420" || window.location.port === "5173";
+      if (isDashboard && !isTest && !devToken) {
+        setTokenMissing(true);
+      }
+    }
+  }, [devToken]);
   const subscribe = React.useCallback((callback) => {
     listeners.current.add(callback);
     return () => listeners.current.delete(callback);
   }, []);
+  const apiFetch = React.useCallback(async (input, init) => {
+    const headers = new Headers(init?.headers || {});
+    if (devToken) {
+      headers.set("Authorization", `Bearer ${devToken}`);
+    }
+    const method = init?.method?.toUpperCase() || "GET";
+    if (["POST", "PUT", "PATCH", "DELETE"].includes(method)) {
+      headers.set("X-Hardkas-Request", "true");
+    }
+    const mergedInit = {
+      ...init,
+      headers
+    };
+    const response = await fetch(input, mergedInit);
+    const genHeader = response.headers?.get?.("X-Hardkas-Generation");
+    if (genHeader) {
+      setGenerationId((prev) => {
+        if (prev !== genHeader) {
+          setTimeout(() => {
+            if (queryClient) queryClient.invalidateQueries();
+          }, 0);
+          return genHeader;
+        }
+        return prev;
+      });
+    }
+    return response;
+  }, [queryClient, devToken]);
   const connect = React.useCallback(() => {
     if (typeof window === "undefined") return;
     if (!config.devServerUrl) {
@@ -35,9 +86,20 @@ function HardKasProvider({ config, children, queryClient: externalQueryClient })
     }
     setSseStatus("connecting");
     const baseUrl = config.devServerUrl;
-    const url = baseUrl.endsWith("/") ? `${baseUrl}api/stream` : `${baseUrl}/api/stream`;
+    let url = baseUrl.endsWith("/") ? `${baseUrl}api/stream` : `${baseUrl}/api/stream`;
+    if (devToken) {
+      url += (url.includes("?") ? "&" : "?") + `token=${encodeURIComponent(devToken)}`;
+    }
     const es = new EventSource(url);
     eventSource.current = es;
+    if (typeof window !== "undefined") {
+      window.__MOCK_SSE_CLOSE__ = () => {
+        es.close();
+        if (es.onerror) {
+          es.onerror.call(es, new Event("error"));
+        }
+      };
+    }
     es.onopen = () => {
       setSseStatus("connected");
       backoffMs.current = 500;
@@ -70,6 +132,9 @@ function HardKasProvider({ config, children, queryClient: externalQueryClient })
       "sandbox-session-paired",
       "sandbox-session-expired",
       "sandbox-session-disconnected",
+      "projection-stale",
+      "projection-synced",
+      "query-synced",
       "ping",
       "heartbeat"
     ];
@@ -82,9 +147,20 @@ function HardKasProvider({ config, children, queryClient: externalQueryClient })
         };
         setLastEvent(event);
         listeners.current.forEach((l) => l(event));
+        if (type === "projection-stale") {
+          setProjectionStatus("stale");
+        }
+        if (type === "projection-synced" || type === "query-synced") {
+          setProjectionStatus("synced");
+          setLastSyncedAt((/* @__PURE__ */ new Date()).toISOString());
+          if (event.payload?.generationId) {
+            setGenerationId(event.payload.generationId);
+          }
+          queryClient.invalidateQueries();
+        }
       });
     });
-  }, [config.devServerUrl]);
+  }, [config.devServerUrl, queryClient, devToken]);
   React.useEffect(() => {
     connect();
     return () => {
@@ -248,6 +324,10 @@ function HardKasProvider({ config, children, queryClient: externalQueryClient })
     igraClient,
     queryClient,
     sseStatus,
+    projectionStatus,
+    generationId,
+    lastSyncedAt,
+    apiFetch,
     lastEvent,
     subscribe,
     providers,
@@ -262,6 +342,10 @@ function HardKasProvider({ config, children, queryClient: externalQueryClient })
     igraClient,
     queryClient,
     sseStatus,
+    projectionStatus,
+    generationId,
+    lastSyncedAt,
+    apiFetch,
     lastEvent,
     subscribe,
     providers,
@@ -272,7 +356,30 @@ function HardKasProvider({ config, children, queryClient: externalQueryClient })
     disconnectWallet,
     switchChain
   ]);
-  return /* @__PURE__ */ jsx(HardKasContext.Provider, { value, children: /* @__PURE__ */ jsx(QueryClientProvider, { client: queryClient, children }) });
+  return /* @__PURE__ */ jsx(HardKasContext.Provider, { value, children: /* @__PURE__ */ jsx(QueryClientProvider, { client: queryClient, children: tokenMissing ? /* @__PURE__ */ jsx("div", { style: {
+    display: "flex",
+    flexDirection: "column",
+    alignItems: "center",
+    justifyContent: "center",
+    height: "100vh",
+    width: "100vw",
+    backgroundColor: "#1a1a1a",
+    color: "#f87171",
+    fontFamily: "sans-serif",
+    textAlign: "center",
+    padding: "20px"
+  }, children: /* @__PURE__ */ jsxs("div", { style: {
+    backgroundColor: "#2d2d2d",
+    border: "2px solid #ef4444",
+    borderRadius: "8px",
+    padding: "30px",
+    maxWidth: "450px",
+    boxShadow: "0 10px 15px -3px rgba(0, 0, 0, 0.5)"
+  }, children: [
+    /* @__PURE__ */ jsx("h2", { style: { color: "#ef4444", marginTop: 0 }, children: "Dashboard authentication token missing." }),
+    /* @__PURE__ */ jsx("p", { style: { color: "#d1d5db", lineHeight: "1.5" }, children: "The dev-server is secured against local workstation CSRF and DNS rebinding attacks." }),
+    /* @__PURE__ */ jsx("p", { style: { color: "#9ca3af", fontWeight: "bold" }, children: "Restart hardkas dashboard." })
+  ] }) }) : children }) });
 }
 function useHardKas() {
   const context = useContext(HardKasContext);
@@ -286,7 +393,7 @@ function useHardKas() {
 import { useQuery, useQueryClient } from "@tanstack/react-query";
 import { useEffect } from "react";
 function useHardKasSession(name) {
-  const { config, subscribe } = useHardKas();
+  const { config, subscribe, apiFetch } = useHardKas();
   const queryClient = useQueryClient();
   const sessionToResolve = name || config.sessionName;
   useEffect(() => {
@@ -303,7 +410,7 @@ function useHardKasSession(name) {
       try {
         const baseUrl = config.devServerUrl || "";
         const url = baseUrl ? baseUrl.endsWith("/") ? `${baseUrl}api/session` : `${baseUrl}/api/session` : "/api/session";
-        const response = await fetch(url);
+        const response = await apiFetch(url);
         const json = await response.json();
         const active = json.active;
         if (!active) return null;
@@ -329,7 +436,7 @@ function useHardKasSession(name) {
 import { useQuery as useQuery2, useQueryClient as useQueryClient2 } from "@tanstack/react-query";
 import { useEffect as useEffect2 } from "react";
 function useHardKasHealth() {
-  const { config, subscribe } = useHardKas();
+  const { config, subscribe, apiFetch } = useHardKas();
   const queryClient = useQueryClient2();
   useEffect2(() => {
     const sync = () => queryClient.invalidateQueries({ queryKey: ["hardkas", "health"] });
@@ -345,7 +452,7 @@ function useHardKasHealth() {
       try {
         const baseUrl = config.devServerUrl || "";
         const url = baseUrl ? baseUrl.endsWith("/") ? `${baseUrl}api/health` : `${baseUrl}/api/health` : "/api/health";
-        const res = await fetch(url);
+        const res = await apiFetch(url);
         if (!res || !res.ok) {
           throw new Error("Failed to fetch health from dev server");
         }
@@ -362,7 +469,8 @@ function useHardKasHealth() {
 }
 
 // src/hooks/kaspa.ts
-import { useQuery as useQuery3 } from "@tanstack/react-query";
+import { useQuery as useQuery3, useQueryClient as useQueryClient3 } from "@tanstack/react-query";
+import { useEffect as useEffect3 } from "react";
 function useKaspaWallet() {
   const { data: session } = useHardKasSession();
   return {
@@ -372,9 +480,18 @@ function useKaspaWallet() {
   };
 }
 function useKaspaBalance(options = {}) {
-  const { config } = useHardKas();
+  const { config, subscribe, apiFetch } = useHardKas();
+  const queryClient = useQueryClient3();
   const { address, name } = useKaspaWallet();
   const { data: health } = useHardKasHealth();
+  useEffect3(() => {
+    const sync = () => queryClient.invalidateQueries({ queryKey: ["kaspa", "balance"] });
+    return subscribe((event) => {
+      if (["query-synced", "session-changed"].includes(event.type)) {
+        sync();
+      }
+    });
+  }, [queryClient, subscribe]);
   const l1Status = health?.kaspa?.status || health?.l1?.status;
   const isL1Online = l1Status === "healthy" || l1Status === "simulated-mode" || l1Status === "ok" || l1Status === "running" || l1Status === "online" || !!address && address.startsWith("kaspa:sim_");
   return useQuery3({
@@ -382,7 +499,21 @@ function useKaspaBalance(options = {}) {
     queryFn: async () => {
       if (!address) return 0n;
       if (address.startsWith("kaspa:sim_") || l1Status === "simulated-mode") {
-        return 100000000000n;
+        try {
+          const baseUrl = config.devServerUrl || "";
+          const fetchUrl = baseUrl ? baseUrl.endsWith("/") ? `${baseUrl}api/accounts` : `${baseUrl}/api/accounts` : "/api/accounts";
+          const res = await apiFetch(fetchUrl);
+          if (res.ok) {
+            const data = await res.json();
+            const match = (data.accounts || []).find((a) => a.address === address);
+            if (match) {
+              return BigInt(match.balanceSompi || match.balance || "0");
+            }
+          }
+        } catch (e) {
+          console.warn("Failed to fetch derived simulated balance, falling back to 0:", e);
+        }
+        return 0n;
       }
       let url = config.kaspaRpcUrl || "http://127.0.0.1:16110";
       if (url.includes("127.0.0.1:16110") || url.includes("localhost:16110")) {
@@ -433,7 +564,7 @@ function useKaspaBalance(options = {}) {
         }
       }
       try {
-        const response = await fetch(url, {
+        const response = await apiFetch(url, {
           method: "POST",
           headers: { "Content-Type": "application/json" },
           body: JSON.stringify({
@@ -455,10 +586,11 @@ function useKaspaBalance(options = {}) {
 }
 
 // src/hooks/igra.ts
-import { useQuery as useQuery4 } from "@tanstack/react-query";
+import { useQuery as useQuery4, useQueryClient as useQueryClient4 } from "@tanstack/react-query";
+import { useEffect as useEffect4 } from "react";
 function useIgraAccount() {
   const { data: session } = useHardKasSession();
-  const { walletAddress } = useHardKas();
+  const { walletAddress, apiFetch } = useHardKas();
   const address = walletAddress || session?.l2.address;
   return {
     name: walletAddress ? "Browser Wallet" : session?.l2.account,
@@ -475,7 +607,8 @@ function useIgraWallet() {
     walletChainId,
     connectWallet,
     disconnectWallet,
-    switchChain
+    switchChain,
+    apiFetch
   } = useHardKas();
   return {
     providers,
@@ -489,10 +622,18 @@ function useIgraWallet() {
   };
 }
 function useIgraBalance(options = {}) {
-  const { igraClient } = useHardKas();
+  const { igraClient, config, subscribe, apiFetch } = useHardKas();
+  const queryClient = useQueryClient4();
   const { address } = useIgraAccount();
+  useEffect4(() => {
+    const sync = () => queryClient.invalidateQueries({ queryKey: ["igra", "balance"] });
+    return subscribe((event) => {
+      if (["query-synced", "session-changed"].includes(event.type)) {
+        sync();
+      }
+    });
+  }, [queryClient, subscribe]);
   const { data: session } = useHardKasSession();
-  const { config } = useHardKas();
   const { data: health } = useHardKasHealth();
   const l2Status = health?.igra?.status || health?.l2?.status;
   const isL2Online = l2Status === "healthy" || l2Status === "ok" || l2Status === "running" || l2Status === "online" || !!address && (address.startsWith("0xsim_") || address.startsWith("kaspa:sim_") || !address.startsWith("0x"));
@@ -501,7 +642,23 @@ function useIgraBalance(options = {}) {
     queryFn: async () => {
       if (!address) return 0n;
       if (address.startsWith("0xsim_") || !address.startsWith("0x") || l2Status === "simulated-mode") {
-        return 500000000000000000000n;
+        try {
+          const baseUrl = config.devServerUrl || "";
+          const fetchUrl = baseUrl ? baseUrl.endsWith("/") ? `${baseUrl}api/accounts` : `${baseUrl}/api/accounts` : "/api/accounts";
+          const res = await apiFetch(fetchUrl);
+          if (res.ok) {
+            const data = await res.json();
+            const match = (data.accounts || []).find(
+              (a) => a.address.toLowerCase() === address.toLowerCase() || a.name.toLowerCase() === address.toLowerCase()
+            );
+            if (match) {
+              return BigInt(match.balanceSompi || match.balance || "0");
+            }
+          }
+        } catch (e) {
+          console.warn("Failed to fetch derived simulated L2 balance, falling back to 0:", e);
+        }
+        return 0n;
       }
       try {
         return await igraClient.getBalance({ address });
@@ -514,48 +671,56 @@ function useIgraBalance(options = {}) {
   });
 }
 
-// src/hooks/bridge.ts
-import { useQuery as useQuery5, useMutation } from "@tanstack/react-query";
-import { planBridgeEntry, simulatePrefixMining } from "@hardkas/bridge-local";
-function useBridgeLocalPlan(options) {
-  const { data: session } = useHardKasSession();
-  const { config } = useHardKas();
+// src/hooks/events.ts
+import { useQuery as useQuery5 } from "@tanstack/react-query";
+import { useEffect as useEffect5 } from "react";
+import { useQueryClient as useQueryClient5 } from "@tanstack/react-query";
+function useEvents(kind, txId) {
+  const { config, subscribe, apiFetch } = useHardKas();
+  const queryClient = useQueryClient5();
+  const queryKey = ["hardkas", "events", kind, txId];
+  useEffect5(() => {
+    return subscribe((event) => {
+      queryClient.invalidateQueries({ queryKey: ["hardkas", "events"] });
+    });
+  }, [queryClient, subscribe]);
   return useQuery5({
-    queryKey: ["bridge", "plan", session?.name, options?.amountSompi.toString(), options?.toIgra, config.localOnly],
+    queryKey,
     queryFn: async () => {
-      if (!session || !options) return null;
-      const targetAddress = options.toIgra || session.l2.address;
-      if (!targetAddress) throw new Error("Target Igra address is required.");
-      return planBridgeEntry({
-        fromAddress: session.l1.address,
-        targetEvmAddress: targetAddress,
-        amountSompi: options.amountSompi,
-        networkId: "simnet",
-        // Fixed for local simulation
-        availableUtxos: [
-          {
-            outpoint: { transactionId: "mock-utxo", index: 0 },
-            address: session.l1.address,
-            amountSompi: options.amountSompi * 2n,
-            scriptPublicKey: "mock-script"
-          }
-        ]
-      });
+      try {
+        const baseUrl = config.devServerUrl || "";
+        const queryParams = new URLSearchParams();
+        if (kind) queryParams.append("kind", kind);
+        if (txId) queryParams.append("txId", txId);
+        const queryStr = queryParams.toString() ? `?${queryParams.toString()}` : "";
+        const url = baseUrl ? baseUrl.endsWith("/") ? `${baseUrl}api/events${queryStr}` : `${baseUrl}/api/events${queryStr}` : `/api/events${queryStr}`;
+        const response = await apiFetch(url);
+        if (!response.ok) return { events: [] };
+        const data = await response.json();
+        return {
+          events: data.events || [],
+          observabilityDrift: data.observabilityDrift,
+          reason: data.reason
+        };
+      } catch (e) {
+        console.error("Failed to fetch events from dev server:", e);
+        return { events: [] };
+      }
     },
-    enabled: !!session && !!options
-  });
-}
-function useBridgeLocalSimulation() {
-  return useMutation({
-    mutationFn: async (params) => {
-      return simulatePrefixMining(params.payloadBase, params.prefix, { timeoutMs: 1e4 });
-    }
+    staleTime: 5e3
   });
 }
 
 // src/hooks/metamask.ts
-import { useState, useEffect as useEffect3, useCallback } from "react";
+import { useState, useEffect as useEffect6, useCallback } from "react";
 import { createWalletClient, custom } from "viem";
+var getMetaMaskProvider = () => {
+  if (typeof window === "undefined" || !window.ethereum) return null;
+  if (window.ethereum.providers) {
+    return window.ethereum.providers.find((p) => p.isMetaMask) || window.ethereum;
+  }
+  return window.ethereum;
+};
 function useMetaMaskLocal() {
   const [state, setState] = useState({
     installed: false,
@@ -565,12 +730,12 @@ function useMetaMaskLocal() {
     errors: []
   });
   const checkStatus = useCallback(async () => {
-    if (typeof window === "undefined" || !window.ethereum) {
+    const provider = getMetaMaskProvider();
+    if (!provider) {
       setState((s) => ({ ...s, installed: false }));
       return;
     }
     try {
-      const provider = window.ethereum;
       const chainIdHex = await provider.request({ method: "eth_chainId" });
       const chainId = parseInt(chainIdHex, 16);
       const accounts = await provider.request({ method: "eth_accounts" });
@@ -588,17 +753,18 @@ function useMetaMaskLocal() {
     }
   }, []);
   const connect = useCallback(async () => {
-    if (typeof window === "undefined" || !window.ethereum) return;
+    const provider = getMetaMaskProvider();
+    if (!provider) return;
     try {
-      await window.ethereum.request({ method: "eth_requestAccounts" });
+      await provider.request({ method: "eth_requestAccounts" });
       await checkStatus();
     } catch (e) {
       setState((s) => ({ ...s, errors: [...s.errors, e.message] }));
     }
   }, [checkStatus]);
-  useEffect3(() => {
-    if (typeof window === "undefined" || !window.ethereum) return;
-    const provider = window.ethereum;
+  useEffect6(() => {
+    const provider = getMetaMaskProvider();
+    if (!provider) return;
     checkStatus();
     const handleChange = () => checkStatus();
     provider.on("accountsChanged", handleChange);
@@ -616,16 +782,17 @@ function useMetaMaskLocal() {
 }
 function useSwitchToLocalIgra() {
   const switchChain = async () => {
-    if (typeof window === "undefined" || !window.ethereum) return;
+    const provider = getMetaMaskProvider();
+    if (!provider) return;
     try {
-      await window.ethereum.request({
+      await provider.request({
         method: "wallet_switchEthereumChain",
         params: [{ chainId: "0x4bd8" }]
         // 19416
       });
     } catch (e) {
       if (e.code === 4902) {
-        await window.ethereum.request({
+        await provider.request({
           method: "wallet_addEthereumChain",
           params: [{
             chainId: "0x4bd8",
@@ -651,17 +818,18 @@ function useIgraInjectedAccount(sessionL2Address) {
 function useLocalIgraWalletClient() {
   const { state } = useMetaMaskLocal();
   const getClient = useCallback(() => {
-    if (!state.connected || !window.ethereum) return null;
+    const provider = getMetaMaskProvider();
+    if (!state.connected || !provider) return null;
     return createWalletClient({
       account: state.account,
-      transport: custom(window.ethereum)
+      transport: custom(provider)
     });
   }, [state.connected, state.account]);
   return { getClient };
 }
 
 // src/hooks/kasware.ts
-import { useState as useState2, useEffect as useEffect4, useCallback as useCallback2 } from "react";
+import { useState as useState2, useEffect as useEffect7, useCallback as useCallback2 } from "react";
 function useKasWareLocal() {
   const [state, setState] = useState2({
     installed: false,
@@ -693,7 +861,7 @@ function useKasWareLocal() {
       setState((s) => ({ ...s, errors: [e.message] }));
     }
   }, []);
-  useEffect4(() => {
+  useEffect7(() => {
     if (typeof window === "undefined" || !window.kasware) return;
     const provider = window.kasware;
     checkStatus();
@@ -753,12 +921,12 @@ function useKasWareSessionMatch(sessionL1Address) {
 }
 
 // src/hooks/sandbox.ts
-import { useQuery as useQuery6, useMutation as useMutation2, useQueryClient as useQueryClient3 } from "@tanstack/react-query";
-import { useEffect as useEffect5 } from "react";
+import { useQuery as useQuery6, useMutation, useQueryClient as useQueryClient6 } from "@tanstack/react-query";
+import { useEffect as useEffect8 } from "react";
 function useSandboxSessions() {
-  const { config, subscribe } = useHardKas();
-  const queryClient = useQueryClient3();
-  useEffect5(() => {
+  const { config, subscribe, apiFetch } = useHardKas();
+  const queryClient = useQueryClient6();
+  useEffect8(() => {
     const sync = () => queryClient.invalidateQueries({ queryKey: ["sandbox", "sessions"] });
     return subscribe((event) => {
       if ([
@@ -776,20 +944,20 @@ function useSandboxSessions() {
     queryFn: async () => {
       const baseUrl = config.devServerUrl || "";
       const url = baseUrl ? baseUrl.endsWith("/") ? `${baseUrl}api/walletconnect/sandbox/sessions` : `${baseUrl}/api/walletconnect/sandbox/sessions` : "/api/walletconnect/sandbox/sessions";
-      const res = await fetch(url);
+      const res = await apiFetch(url);
       const json = await res.json();
       return json.sessions;
     }
   });
 }
 function useCreateSandboxSession() {
-  const { config } = useHardKas();
-  const queryClient = useQueryClient3();
-  return useMutation2({
+  const { config, apiFetch } = useHardKas();
+  const queryClient = useQueryClient6();
+  return useMutation({
     mutationFn: async () => {
       const baseUrl = config.devServerUrl || "";
       const url = baseUrl ? baseUrl.endsWith("/") ? `${baseUrl}api/walletconnect/sandbox/create` : `${baseUrl}/api/walletconnect/sandbox/create` : "/api/walletconnect/sandbox/create";
-      const res = await fetch(url, { method: "POST" });
+      const res = await apiFetch(url, { method: "POST" });
       return await res.json();
     },
     onSuccess: () => {
@@ -798,13 +966,13 @@ function useCreateSandboxSession() {
   });
 }
 function usePairSandboxSession() {
-  const { config } = useHardKas();
-  const queryClient = useQueryClient3();
-  return useMutation2({
+  const { config, apiFetch } = useHardKas();
+  const queryClient = useQueryClient6();
+  return useMutation({
     mutationFn: async (id) => {
       const baseUrl = config.devServerUrl || "";
       const url = baseUrl ? baseUrl.endsWith("/") ? `${baseUrl}api/walletconnect/sandbox/pair` : `${baseUrl}/api/walletconnect/sandbox/pair` : "/api/walletconnect/sandbox/pair";
-      const res = await fetch(url, {
+      const res = await apiFetch(url, {
         method: "POST",
         headers: { "Content-Type": "application/json" },
         body: JSON.stringify({ id })
@@ -817,13 +985,13 @@ function usePairSandboxSession() {
   });
 }
 function useDisconnectSandboxSession() {
-  const { config } = useHardKas();
-  const queryClient = useQueryClient3();
-  return useMutation2({
+  const { config, apiFetch } = useHardKas();
+  const queryClient = useQueryClient6();
+  return useMutation({
     mutationFn: async (id) => {
       const baseUrl = config.devServerUrl || "";
       const url = baseUrl ? baseUrl.endsWith("/") ? `${baseUrl}api/walletconnect/sandbox/disconnect` : `${baseUrl}/api/walletconnect/sandbox/disconnect` : "/api/walletconnect/sandbox/disconnect";
-      const res = await fetch(url, {
+      const res = await apiFetch(url, {
         method: "POST",
         headers: { "Content-Type": "application/json" },
         body: JSON.stringify({ id })
@@ -837,7 +1005,7 @@ function useDisconnectSandboxSession() {
 }
 
 // src/hooks/contracts.ts
-import { useQuery as useQuery7, useMutation as useMutation3 } from "@tanstack/react-query";
+import { useQuery as useQuery7, useMutation as useMutation2 } from "@tanstack/react-query";
 import { createWalletClient as createWalletClient2, custom as custom2 } from "viem";
 function useIgraReadContract(options) {
   const { igraClient, config } = useHardKas();
@@ -858,7 +1026,7 @@ function useIgraReadContract(options) {
 }
 function useIgraWriteContract() {
   const { activeProvider, walletAddress, igraClient } = useHardKas();
-  return useMutation3({
+  return useMutation2({
     mutationFn: async (params) => {
       let client = params.walletClient;
       if (!client) {
@@ -885,19 +1053,370 @@ function useIgraWriteContract() {
 }
 function useIgraWaitForReceipt() {
   const { igraClient } = useHardKas();
-  return useMutation3({
+  return useMutation2({
     mutationFn: async (hash) => {
       return await igraClient.waitForTransactionReceipt({ hash });
     }
   });
 }
+
+// src/hooks/overview.ts
+import { useQuery as useQuery8, useQueryClient as useQueryClient7 } from "@tanstack/react-query";
+import { useEffect as useEffect9 } from "react";
+function useOverview() {
+  const { config, subscribe, apiFetch } = useHardKas();
+  const queryClient = useQueryClient7();
+  useEffect9(() => {
+    const sync = () => queryClient.invalidateQueries({ queryKey: ["hardkas", "overview"] });
+    return subscribe((event) => {
+      if (["query-synced", "session-changed"].includes(event.type)) {
+        sync();
+      }
+    });
+  }, [queryClient, subscribe]);
+  return useQuery8({
+    queryKey: ["hardkas", "overview"],
+    queryFn: async () => {
+      try {
+        const baseUrl = config.devServerUrl || "";
+        const url = baseUrl ? baseUrl.endsWith("/") ? `${baseUrl}api/overview` : `${baseUrl}/api/overview` : "/api/overview";
+        const response = await apiFetch(url);
+        if (!response.ok) return null;
+        return await response.json();
+      } catch (e) {
+        console.error("Failed to fetch overview stats from dev server:", e);
+        return null;
+      }
+    },
+    staleTime: 6e4
+  });
+}
+
+// src/hooks/accounts.ts
+import { useQuery as useQuery9, useQueryClient as useQueryClient8 } from "@tanstack/react-query";
+import { useEffect as useEffect10 } from "react";
+function useAccounts() {
+  const { config, subscribe, apiFetch } = useHardKas();
+  const queryClient = useQueryClient8();
+  useEffect10(() => {
+    const sync = () => queryClient.invalidateQueries({ queryKey: ["hardkas", "accounts"] });
+    return subscribe((event) => {
+      if (["query-synced", "session-changed"].includes(event.type)) {
+        sync();
+      }
+    });
+  }, [queryClient, subscribe]);
+  return useQuery9({
+    queryKey: ["hardkas", "accounts"],
+    queryFn: async () => {
+      try {
+        const baseUrl = config.devServerUrl || "";
+        const url = baseUrl ? baseUrl.endsWith("/") ? `${baseUrl}api/accounts` : `${baseUrl}/api/accounts` : "/api/accounts";
+        const response = await apiFetch(url);
+        if (!response.ok) return { accounts: [] };
+        const data = await response.json();
+        return data || { accounts: [] };
+      } catch (e) {
+        console.error("Failed to fetch accounts from dev server:", e);
+        return { accounts: [] };
+      }
+    },
+    staleTime: 3e4
+  });
+}
+
+// src/hooks/transactions.ts
+import { useQuery as useQuery10, useQueryClient as useQueryClient9 } from "@tanstack/react-query";
+import { useEffect as useEffect11 } from "react";
+function useTransactions() {
+  const { config, subscribe, apiFetch } = useHardKas();
+  const queryClient = useQueryClient9();
+  useEffect11(() => {
+    const sync = () => queryClient.invalidateQueries({ queryKey: ["hardkas", "transactions"] });
+    return subscribe((event) => {
+      if (["query-synced", "session-changed"].includes(event.type)) {
+        sync();
+      }
+    });
+  }, [queryClient, subscribe]);
+  return useQuery10({
+    queryKey: ["hardkas", "transactions"],
+    queryFn: async () => {
+      try {
+        const baseUrl = config.devServerUrl || "";
+        const url = baseUrl ? baseUrl.endsWith("/") ? `${baseUrl}api/transactions` : `${baseUrl}/api/transactions` : "/api/transactions";
+        const response = await apiFetch(url);
+        if (!response.ok) return [];
+        const data = await response.json();
+        return data.transactions || [];
+      } catch (e) {
+        console.error("Failed to fetch transactions from dev server:", e);
+        return [];
+      }
+    },
+    staleTime: 1e4
+  });
+}
+function useTransaction(id) {
+  const { config, subscribe, apiFetch } = useHardKas();
+  const queryClient = useQueryClient9();
+  useEffect11(() => {
+    const sync = () => queryClient.invalidateQueries({ queryKey: ["hardkas", "transaction", id] });
+    return subscribe((event) => {
+      if (["query-synced", "session-changed"].includes(event.type)) {
+        sync();
+      }
+    });
+  }, [id, queryClient, subscribe]);
+  return useQuery10({
+    queryKey: ["hardkas", "transaction", id],
+    queryFn: async () => {
+      if (!id) return null;
+      try {
+        const baseUrl = config.devServerUrl || "";
+        const url = baseUrl ? baseUrl.endsWith("/") ? `${baseUrl}api/transactions/${id}` : `${baseUrl}/api/transactions/${id}` : `/api/transactions/${id}`;
+        const response = await apiFetch(url);
+        if (!response.ok) return null;
+        return await response.json();
+      } catch (e) {
+        console.error(`Failed to fetch transaction detail for '${id}':`, e);
+        return null;
+      }
+    },
+    enabled: !!id,
+    staleTime: 1e4
+  });
+}
+
+// src/hooks/artifacts.ts
+import { useQuery as useQuery11, useQueryClient as useQueryClient10 } from "@tanstack/react-query";
+import { useEffect as useEffect12 } from "react";
+function useArtifacts(schemaFilter) {
+  const { config, subscribe, apiFetch } = useHardKas();
+  const queryClient = useQueryClient10();
+  useEffect12(() => {
+    const sync = () => queryClient.invalidateQueries({ queryKey: ["hardkas", "artifacts", schemaFilter || "all"] });
+    return subscribe((event) => {
+      if (["query-synced", "session-changed"].includes(event.type)) {
+        sync();
+      }
+    });
+  }, [schemaFilter, queryClient, subscribe]);
+  return useQuery11({
+    queryKey: ["hardkas", "artifacts", schemaFilter || "all"],
+    queryFn: async () => {
+      try {
+        const baseUrl = config.devServerUrl || "";
+        const queryParams = schemaFilter ? `?schema=${schemaFilter}` : "";
+        const url = baseUrl ? baseUrl.endsWith("/") ? `${baseUrl}api/artifacts${queryParams}` : `${baseUrl}/api/artifacts${queryParams}` : `/api/artifacts${queryParams}`;
+        const response = await apiFetch(url);
+        if (!response.ok) return [];
+        const data = await response.json();
+        return data.artifacts || [];
+      } catch (e) {
+        console.error("Failed to fetch artifacts from dev server:", e);
+        return [];
+      }
+    },
+    staleTime: 3e4
+  });
+}
+function useArtifact(id) {
+  const { config, subscribe, apiFetch } = useHardKas();
+  const queryClient = useQueryClient10();
+  useEffect12(() => {
+    const sync = () => queryClient.invalidateQueries({ queryKey: ["hardkas", "artifact", id] });
+    return subscribe((event) => {
+      if (["query-synced", "session-changed"].includes(event.type)) {
+        sync();
+      }
+    });
+  }, [id, queryClient, subscribe]);
+  return useQuery11({
+    queryKey: ["hardkas", "artifact", id],
+    queryFn: async () => {
+      if (!id) return null;
+      try {
+        const baseUrl = config.devServerUrl || "";
+        const url = baseUrl ? baseUrl.endsWith("/") ? `${baseUrl}api/artifacts/${id}` : `${baseUrl}/api/artifacts/${id}` : `/api/artifacts/${id}`;
+        const response = await apiFetch(url);
+        if (!response.ok) return null;
+        const data = await response.json();
+        return data.artifact || null;
+      } catch (e) {
+        console.error(`Failed to fetch artifact detail for '${id}':`, e);
+        return null;
+      }
+    },
+    enabled: !!id,
+    staleTime: 3e4
+  });
+}
+
+// src/hooks/replay.ts
+import { useQuery as useQuery12, useQueryClient as useQueryClient11 } from "@tanstack/react-query";
+import { useEffect as useEffect13 } from "react";
+function useReplayStatus() {
+  const { config, subscribe, apiFetch } = useHardKas();
+  const queryClient = useQueryClient11();
+  useEffect13(() => {
+    const sync = () => queryClient.invalidateQueries({ queryKey: ["hardkas", "replay"] });
+    return subscribe((event) => {
+      if (["query-synced", "session-changed"].includes(event.type)) {
+        sync();
+      }
+    });
+  }, [queryClient, subscribe]);
+  return useQuery12({
+    queryKey: ["hardkas", "replay"],
+    queryFn: async () => {
+      try {
+        const baseUrl = config.devServerUrl || "";
+        const url = baseUrl ? baseUrl.endsWith("/") ? `${baseUrl}api/replay` : `${baseUrl}/api/replay` : "/api/replay";
+        const response = await apiFetch(url);
+        if (!response.ok) return { replays: [], pendingReplays: [], pendingReplay: false };
+        const data = await response.json();
+        const formatReplay = (r) => {
+          return {
+            artifactId: r.artifactId,
+            txId: r.payload?.txId || r.txId,
+            planOk: r.payload?.planOk ?? false,
+            receiptOk: r.payload?.receiptOk ?? false,
+            invariantsOk: r.payload?.invariantsOk ?? false,
+            ok: r.payload?.planOk && r.payload?.receiptOk && r.payload?.invariantsOk ? true : false,
+            checks: r.payload?.checks || {
+              workflowDeterministic: "unknown",
+              consensusValidation: "unknown",
+              l2BridgeCorrectness: "unknown"
+            },
+            errors: r.payload?.errors || [],
+            divergencesCount: r.payload?.divergencesCount || 0,
+            createdAt: r.createdAt || r.timestamp || (/* @__PURE__ */ new Date()).toISOString()
+          };
+        };
+        return {
+          replays: (data.replays || []).map(formatReplay),
+          pendingReplays: data.pendingReplays || [],
+          pendingReplay: data.pendingReplay || false,
+          reason: data.reason
+        };
+      } catch (e) {
+        console.error("Failed to fetch replay status from dev server:", e);
+        return { replays: [], pendingReplays: [], pendingReplay: false };
+      }
+    },
+    staleTime: 3e4
+  });
+}
+function useReplayDetail(txId) {
+  const { config, subscribe, apiFetch } = useHardKas();
+  const queryClient = useQueryClient11();
+  useEffect13(() => {
+    const sync = () => queryClient.invalidateQueries({ queryKey: ["hardkas", "replay", txId] });
+    return subscribe((event) => {
+      if (["query-synced", "session-changed"].includes(event.type)) {
+        sync();
+      }
+    });
+  }, [txId, queryClient, subscribe]);
+  return useQuery12({
+    queryKey: ["hardkas", "replay", txId],
+    queryFn: async () => {
+      if (!txId) return null;
+      try {
+        const baseUrl = config.devServerUrl || "";
+        const url = baseUrl ? baseUrl.endsWith("/") ? `${baseUrl}api/replay/${txId}` : `${baseUrl}/api/replay/${txId}` : `/api/replay/${txId}`;
+        const response = await apiFetch(url);
+        if (!response.ok) return null;
+        const data = await response.json();
+        return data.replay || null;
+      } catch (e) {
+        console.error(`Failed to fetch replay details for transaction '${txId}':`, e);
+        return null;
+      }
+    },
+    enabled: !!txId,
+    staleTime: 3e4
+  });
+}
+
+// src/hooks/deployments.ts
+import { useQuery as useQuery13, useQueryClient as useQueryClient12 } from "@tanstack/react-query";
+import { useEffect as useEffect14 } from "react";
+function useDeployments() {
+  const { config, subscribe, apiFetch } = useHardKas();
+  const queryClient = useQueryClient12();
+  useEffect14(() => {
+    const sync = () => queryClient.invalidateQueries({ queryKey: ["hardkas", "deployments"] });
+    return subscribe((event) => {
+      if (["query-synced", "session-changed"].includes(event.type)) {
+        sync();
+      }
+    });
+  }, [queryClient, subscribe]);
+  return useQuery13({
+    queryKey: ["hardkas", "deployments"],
+    queryFn: async () => {
+      try {
+        const baseUrl = config.devServerUrl || "";
+        const url = baseUrl ? baseUrl.endsWith("/") ? `${baseUrl}api/deployments` : `${baseUrl}/api/deployments` : "/api/deployments";
+        const response = await apiFetch(url);
+        if (!response.ok) return [];
+        const data = await response.json();
+        return data.deployments || [];
+      } catch (e) {
+        console.error("Failed to fetch deployments from dev server:", e);
+        return [];
+      }
+    },
+    staleTime: 3e4
+  });
+}
+
+// src/hooks/activity.ts
+import { useQuery as useQuery14, useQueryClient as useQueryClient13 } from "@tanstack/react-query";
+import { useEffect as useEffect15 } from "react";
+function useActivity() {
+  const { config, subscribe, apiFetch } = useHardKas();
+  const queryClient = useQueryClient13();
+  useEffect15(() => {
+    const sync = () => queryClient.invalidateQueries({ queryKey: ["hardkas", "activity"] });
+    return subscribe((event) => {
+      if (["query-synced", "session-changed"].includes(event.type)) {
+        sync();
+      }
+    });
+  }, [queryClient, subscribe]);
+  return useQuery14({
+    queryKey: ["hardkas", "activity"],
+    queryFn: async () => {
+      try {
+        const baseUrl = config.devServerUrl || "";
+        const url = baseUrl ? baseUrl.endsWith("/") ? `${baseUrl}api/activity` : `${baseUrl}/api/activity` : "/api/activity";
+        const response = await apiFetch(url);
+        if (!response.ok) return [];
+        const data = await response.json();
+        return data.activity || [];
+      } catch (e) {
+        console.error("Failed to fetch activity from dev server:", e);
+        return [];
+      }
+    },
+    staleTime: 5e3
+    // Frequent updates safe because it's local dev
+  });
+}
 export {
   HardKasProvider,
-  useBridgeLocalPlan,
-  useBridgeLocalSimulation,
+  useAccounts,
+  useActivity,
+  useArtifact,
+  useArtifacts,
   useConnectKasWareLocal,
   useCreateSandboxSession,
+  useDeployments,
   useDisconnectSandboxSession,
+  useEvents,
   useHardKas,
   useHardKasHealth,
   useHardKasSession,
@@ -914,7 +1433,12 @@ export {
   useKaspaWallet,
   useLocalIgraWalletClient,
   useMetaMaskLocal,
+  useOverview,
   usePairSandboxSession,
+  useReplayDetail,
+  useReplayStatus,
   useSandboxSessions,
-  useSwitchToLocalIgra
+  useSwitchToLocalIgra,
+  useTransaction,
+  useTransactions
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hardkas/react",
-  "version": "0.5.5-alpha",
+  "version": "0.6.1-alpha",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -14,11 +14,10 @@
   "dependencies": {
     "@tanstack/react-query": "^5.61.5",
     "viem": "^2.21.51",
-    "@hardkas/bridge-local": "0.5.5-alpha",
-    "@hardkas/kaspa-rpc": "0.5.5-alpha",
-    "@hardkas/core": "0.5.5-alpha",
-    "@hardkas/sessions": "0.5.5-alpha",
-    "@hardkas/l2": "0.5.5-alpha"
+    "@hardkas/core": "0.6.1-alpha",
+    "@hardkas/sessions": "0.6.1-alpha",
+    "@hardkas/kaspa-rpc": "0.6.1-alpha",
+    "@hardkas/l2": "0.6.1-alpha"
   },
   "devDependencies": {
     "@testing-library/dom": "^10.4.1",