@rozenite/network-activity-plugin 1.0.0-alpha.15 → 1.0.0-alpha.16

package/dist/assets/{App-CZPlDq_M.js → App-CM3Ub2ZA.js}

@@ -15062,6 +15062,10 @@ const Check = createLucideIcon$1("Check", [
 const ChevronDown = createLucideIcon$1("ChevronDown", [
   ["path", { d: "m6 9 6 6 6-6", key: "qrunsl" }]
 ]);
+const CircleSlash2 = createLucideIcon$1("CircleSlash2", [
+  ["circle", { cx: "12", cy: "12", r: "10", key: "1mglay" }],
+  ["path", { d: "M22 2 2 22", key: "y4kqgn" }]
+]);
 const Circle = createLucideIcon$1("Circle", [
   ["circle", { cx: "12", cy: "12", r: "10", key: "1mglay" }]
 ]);
@@ -15095,6 +15099,13 @@ const Filter = createLucideIcon$1("Filter", [
 const Loader2 = createLucideIcon$1("Loader2", [
   ["path", { d: "M21 12a9 9 0 1 1-6.219-8.56", key: "13zald" }]
 ]);
+const Pencil = createLucideIcon$1("Pencil", [
+  [
+    "path",
+    { d: "M17 3a2.85 2.83 0 1 1 4 4L7.5 20.5 2 22l1.5-5.5Z", key: "5qss01" }
+  ],
+  ["path", { d: "m15 5 4 4", key: "1mk7zo" }]
+]);
 const Square = createLucideIcon$1("Square", [
   [
     "rect",
@@ -15133,7 +15144,7 @@ const createStoreImpl = (createState) => {
   const initialState = state = createState(setState, getState, api);
   return api;
 };
-const createStore = (createState) => createState ? createStoreImpl(createState) : createStoreImpl;
+const createStore = (createState) => createStoreImpl;
 const identity$2 = (arg) => arg;
 function useStore(api, selector = identity$2) {
   const slice2 = React.useSyncExternalStore(
@@ -15144,6 +15155,192 @@ function useStore(api, selector = identity$2) {
   React.useDebugValue(slice2);
   return slice2;
 }
+function createJSONStorage(getStorage, options) {
+  let storage;
+  try {
+    storage = getStorage();
+  } catch (e) {
+    return;
+  }
+  const persistStorage = {
+    getItem: (name) => {
+      var _a;
+      const parse2 = (str2) => {
+        if (str2 === null) {
+          return null;
+        }
+        return JSON.parse(str2, options == null ? void 0 : options.reviver);
+      };
+      const str = (_a = storage.getItem(name)) != null ? _a : null;
+      if (str instanceof Promise) {
+        return str.then(parse2);
+      }
+      return parse2(str);
+    },
+    setItem: (name, newValue) => storage.setItem(name, JSON.stringify(newValue, options == null ? void 0 : options.replacer)),
+    removeItem: (name) => storage.removeItem(name)
+  };
+  return persistStorage;
+}
+const toThenable = (fn) => (input) => {
+  try {
+    const result = fn(input);
+    if (result instanceof Promise) {
+      return result;
+    }
+    return {
+      then(onFulfilled) {
+        return toThenable(onFulfilled)(result);
+      },
+      catch(_onRejected) {
+        return this;
+      }
+    };
+  } catch (e) {
+    return {
+      then(_onFulfilled) {
+        return this;
+      },
+      catch(onRejected) {
+        return toThenable(onRejected)(e);
+      }
+    };
+  }
+};
+const persistImpl = (config, baseOptions) => (set, get, api) => {
+  let options = {
+    storage: createJSONStorage(() => localStorage),
+    partialize: (state) => state,
+    version: 0,
+    merge: (persistedState, currentState) => ({
+      ...currentState,
+      ...persistedState
+    }),
+    ...baseOptions
+  };
+  let hasHydrated = false;
+  const hydrationListeners = /* @__PURE__ */ new Set();
+  const finishHydrationListeners = /* @__PURE__ */ new Set();
+  let storage = options.storage;
+  if (!storage) {
+    return config(
+      (...args) => {
+        console.warn(
+          `[zustand persist middleware] Unable to update item '${options.name}', the given storage is currently unavailable.`
+        );
+        set(...args);
+      },
+      get,
+      api
+    );
+  }
+  const setItem = () => {
+    const state = options.partialize({ ...get() });
+    return storage.setItem(options.name, {
+      state,
+      version: options.version
+    });
+  };
+  const savedSetState = api.setState;
+  api.setState = (state, replace) => {
+    savedSetState(state, replace);
+    void setItem();
+  };
+  const configResult = config(
+    (...args) => {
+      set(...args);
+      void setItem();
+    },
+    get,
+    api
+  );
+  api.getInitialState = () => configResult;
+  let stateFromStorage;
+  const hydrate2 = () => {
+    var _a, _b;
+    if (!storage) return;
+    hasHydrated = false;
+    hydrationListeners.forEach((cb) => {
+      var _a2;
+      return cb((_a2 = get()) != null ? _a2 : configResult);
+    });
+    const postRehydrationCallback = ((_b = options.onRehydrateStorage) == null ? void 0 : _b.call(options, (_a = get()) != null ? _a : configResult)) || void 0;
+    return toThenable(storage.getItem.bind(storage))(options.name).then((deserializedStorageValue) => {
+      if (deserializedStorageValue) {
+        if (typeof deserializedStorageValue.version === "number" && deserializedStorageValue.version !== options.version) {
+          if (options.migrate) {
+            const migration = options.migrate(
+              deserializedStorageValue.state,
+              deserializedStorageValue.version
+            );
+            if (migration instanceof Promise) {
+              return migration.then((result) => [true, result]);
+            }
+            return [true, migration];
+          }
+          console.error(
+            `State loaded from storage couldn't be migrated since no migrate function was provided`
+          );
+        } else {
+          return [false, deserializedStorageValue.state];
+        }
+      }
+      return [false, void 0];
+    }).then((migrationResult) => {
+      var _a2;
+      const [migrated, migratedState] = migrationResult;
+      stateFromStorage = options.merge(
+        migratedState,
+        (_a2 = get()) != null ? _a2 : configResult
+      );
+      set(stateFromStorage, true);
+      if (migrated) {
+        return setItem();
+      }
+    }).then(() => {
+      postRehydrationCallback == null ? void 0 : postRehydrationCallback(stateFromStorage, void 0);
+      stateFromStorage = get();
+      hasHydrated = true;
+      finishHydrationListeners.forEach((cb) => cb(stateFromStorage));
+    }).catch((e) => {
+      postRehydrationCallback == null ? void 0 : postRehydrationCallback(void 0, e);
+    });
+  };
+  api.persist = {
+    setOptions: (newOptions) => {
+      options = {
+        ...options,
+        ...newOptions
+      };
+      if (newOptions.storage) {
+        storage = newOptions.storage;
+      }
+    },
+    clearStorage: () => {
+      storage == null ? void 0 : storage.removeItem(options.name);
+    },
+    getOptions: () => options,
+    rehydrate: () => hydrate2(),
+    hasHydrated: () => hasHydrated,
+    onHydrate: (cb) => {
+      hydrationListeners.add(cb);
+      return () => {
+        hydrationListeners.delete(cb);
+      };
+    },
+    onFinishHydration: (cb) => {
+      finishHydrationListeners.add(cb);
+      return () => {
+        finishHydrationListeners.delete(cb);
+      };
+    }
+  };
+  if (!options.skipHydration) {
+    hydrate2();
+  }
+  return stateFromStorage || configResult;
+};
+const persist = persistImpl;
 const idMap = /* @__PURE__ */ new Map();
 const getId = (namespace) => {
   if (!idMap.has(namespace)) {
@@ -15196,450 +15393,513 @@ function applyReactNativeRequestHeadersLogic(headers, postData) {
     "Content-Type": inferredContentType
   };
 }
-const createNetworkActivityStore = () => createStore((set, get) => ({
-  // Initial state
-  isRecording: false,
-  selectedRequestId: null,
-  networkEntries: /* @__PURE__ */ new Map(),
-  websocketMessages: /* @__PURE__ */ new Map(),
-  // Actions
-  actions: {
-    setRecording: (isRecording) => {
-      const { _client } = get();
-      assert(!!_client, "Client is not set");
-      _client.send(isRecording ? "network-enable" : "network-disable", {});
-      set({ isRecording });
-    },
-    setSelectedRequest: (requestId) => set({ selectedRequestId: requestId }),
-    clearRequests: () => set({
+const STORE_VERSION = 1;
+const createNetworkActivityStore = () => createStore()(
+  persist(
+    (set, get) => ({
+      // Initial state
+      isRecording: false,
+      selectedRequestId: null,
       networkEntries: /* @__PURE__ */ new Map(),
       websocketMessages: /* @__PURE__ */ new Map(),
-      selectedRequestId: null
-    })
-  },
-  // Event handling
-  handleEvent: (eventType, data) => {
-    switch (eventType) {
-      case "request-sent": {
-        const eventData = data;
-        set((state) => {
-          const headersWithContentType = applyReactNativeRequestHeadersLogic(
-            eventData.request.headers,
-            eventData.request.postData
-          );
-          const requestContentType = getContentTypeMime(headersWithContentType) || "text/plain";
-          const entry = {
-            id: eventData.requestId,
-            type: "http",
-            timestamp: eventData.timestamp,
-            request: {
-              url: eventData.request.url,
-              method: eventData.request.method,
-              headers: headersWithContentType,
-              body: eventData.request.postData ? {
-                type: requestContentType,
-                data: eventData.request.postData
-              } : void 0
-            },
-            status: "pending",
-            initiator: eventData.initiator,
-            resourceType: eventData.type
-          };
-          const newEntries = new Map(state.networkEntries);
-          newEntries.set(eventData.requestId, entry);
-          return { networkEntries: newEntries };
-        });
-        break;
-      }
-      case "response-received": {
-        const eventData = data;
-        set((state) => {
-          const entry = state.networkEntries.get(eventData.requestId);
-          if (!entry || entry.type !== "http") return state;
-          const httpEntry = entry;
-          const updatedEntry = {
-            ...httpEntry,
-            status: "loading",
-            response: eventData.response
-          };
-          const newEntries = new Map(state.networkEntries);
-          newEntries.set(eventData.requestId, updatedEntry);
-          return { networkEntries: newEntries };
-        });
-        break;
-      }
-      case "request-completed": {
-        const eventData = data;
-        set((state) => {
-          const entry = state.networkEntries.get(eventData.requestId);
-          if (!entry || entry.type !== "http") return state;
-          const httpEntry = entry;
-          const updatedEntry = {
-            ...httpEntry,
-            status: "finished",
-            duration: eventData.duration,
-            size: eventData.size,
-            ttfb: eventData.ttfb
-          };
-          const newEntries = new Map(state.networkEntries);
-          newEntries.set(eventData.requestId, updatedEntry);
-          return { networkEntries: newEntries };
-        });
-        break;
-      }
-      case "request-failed": {
-        const eventData = data;
-        set((state) => {
-          const entry = state.networkEntries.get(eventData.requestId);
-          if (!entry || entry.type !== "http") return state;
-          const httpEntry = entry;
-          const updatedEntry = {
-            ...httpEntry,
-            status: "failed",
-            error: eventData.error
-          };
-          const newEntries = new Map(state.networkEntries);
-          newEntries.set(eventData.requestId, updatedEntry);
-          return { networkEntries: newEntries };
-        });
-        break;
-      }
-      case "response-body": {
-        const eventData = data;
-        set((state) => {
-          var _a;
-          const entry = state.networkEntries.get(eventData.requestId);
-          if (!entry || entry.type !== "http") return state;
-          const httpEntry = entry;
-          const updatedEntry = {
-            ...httpEntry,
-            response: httpEntry.response ? {
-              ...httpEntry.response,
-              body: eventData.body ? {
-                type: getContentTypeMime(
-                  ((_a = httpEntry.response) == null ? void 0 : _a.headers) ?? {}
-                ) || "text/plain",
-                data: eventData.body
-              } : void 0
-            } : void 0
-          };
-          const newEntries = new Map(state.networkEntries);
-          newEntries.set(eventData.requestId, updatedEntry);
-          return { networkEntries: newEntries };
-        });
-        break;
-      }
-      case "websocket-connect": {
-        const eventData = data;
-        set((state) => {
-          const entry = {
-            id: `ws-${eventData.socketId}`,
-            type: "websocket",
-            timestamp: eventData.timestamp,
-            connection: {
-              url: eventData.url,
-              socketId: eventData.socketId,
-              protocols: eventData.protocols || void 0,
-              options: eventData.options
-            },
-            status: "connecting"
-          };
-          const newEntries = new Map(state.networkEntries);
-          newEntries.set(entry.id, entry);
-          const newMessages = new Map(state.websocketMessages);
-          newMessages.set(entry.id, []);
-          return {
-            networkEntries: newEntries,
-            websocketMessages: newMessages
-          };
-        });
-        break;
-      }
-      case "websocket-open": {
-        const eventData = data;
-        set((state) => {
-          const entry = state.networkEntries.get(`ws-${eventData.socketId}`);
-          if (!entry || entry.type !== "websocket") return state;
-          const wsEntry = entry;
-          const updatedEntry = {
-            ...wsEntry,
-            status: "open"
-          };
-          const newEntries = new Map(state.networkEntries);
-          newEntries.set(entry.id, updatedEntry);
-          return { networkEntries: newEntries };
-        });
-        break;
-      }
-      case "websocket-close": {
-        const eventData = data;
-        set((state) => {
-          const entry = state.networkEntries.get(`ws-${eventData.socketId}`);
-          if (!entry || entry.type !== "websocket") return state;
-          const wsEntry = entry;
-          const updatedEntry = {
-            ...wsEntry,
-            status: "closed",
-            closeCode: eventData.code,
-            closeReason: eventData.reason,
-            duration: eventData.timestamp - wsEntry.timestamp
-          };
-          const newEntries = new Map(state.networkEntries);
-          newEntries.set(entry.id, updatedEntry);
-          return { networkEntries: newEntries };
-        });
-        break;
-      }
-      case "websocket-message-sent": {
-        const eventData = data;
-        set((state) => {
-          const socketId = `ws-${eventData.socketId}`;
-          const currentMessages = state.websocketMessages.get(socketId) || [];
-          const message = {
-            id: getId(`${socketId}-message`),
-            direction: "sent",
-            data: eventData.data,
-            messageType: eventData.messageType,
-            timestamp: eventData.timestamp
-          };
-          const newMessages = new Map(state.websocketMessages);
-          newMessages.set(
-            socketId,
-            [...currentMessages, message].slice(
-              -32
-            )
-          );
-          return { websocketMessages: newMessages };
-        });
-        break;
-      }
-      case "websocket-message-received": {
-        const eventData = data;
-        set((state) => {
-          const socketId = `ws-${eventData.socketId}`;
-          const currentMessages = state.websocketMessages.get(socketId) || [];
-          const message = {
-            id: getId(`${socketId}-message`),
-            direction: "received",
-            data: eventData.data,
-            messageType: eventData.messageType,
-            timestamp: eventData.timestamp
-          };
-          const newMessages = new Map(state.websocketMessages);
-          newMessages.set(
-            socketId,
-            [...currentMessages, message].slice(
-              -32
-            )
+      overrides: /* @__PURE__ */ new Map(),
+      // Actions
+      actions: {
+        setRecording: (isRecording) => {
+          const { _client } = get();
+          assert(!!_client, "Client is not set");
+          _client.send(
+            isRecording ? "network-enable" : "network-disable",
+            {}
           );
-          return { websocketMessages: newMessages };
-        });
-        break;
-      }
-      case "websocket-error": {
-        const eventData = data;
-        set((state) => {
-          const entry = state.networkEntries.get(`ws-${eventData.socketId}`);
-          if (!entry || entry.type !== "websocket") return state;
-          const wsEntry = entry;
-          const updatedEntry = {
-            ...wsEntry,
-            status: "error",
-            error: eventData.error
-          };
-          const newEntries = new Map(state.networkEntries);
-          newEntries.set(entry.id, updatedEntry);
-          return { networkEntries: newEntries };
-        });
-        break;
-      }
-      case "websocket-connection-status-changed": {
-        const eventData = data;
-        set((state) => {
-          const entry = state.networkEntries.get(`ws-${eventData.socketId}`);
-          if (!entry || entry.type !== "websocket") return state;
-          const wsEntry = entry;
-          const updatedEntry = {
-            ...wsEntry,
-            status: eventData.status
-          };
-          const newEntries = new Map(state.networkEntries);
-          newEntries.set(entry.id, updatedEntry);
-          return { networkEntries: newEntries };
-        });
-        break;
-      }
-      case "sse-open": {
-        const eventData = data;
-        set((state) => {
-          const entry = state.networkEntries.get(eventData.requestId);
-          if (!entry || entry.type !== "http") return state;
-          const httpEntry = entry;
-          const sseEntry = {
-            ...httpEntry,
-            type: "sse",
-            // Change type from 'http' to 'sse'
-            status: "open",
-            // Update status
-            messages: [],
-            // Add SSE-specific field
-            response: eventData.response
-          };
-          const newEntries = new Map(state.networkEntries);
-          newEntries.set(eventData.requestId, sseEntry);
-          return { networkEntries: newEntries };
-        });
-        break;
-      }
-      case "sse-message": {
-        const eventData = data;
-        set((state) => {
-          const entry = state.networkEntries.get(eventData.requestId);
-          if (!entry || entry.type !== "sse") return state;
-          const sseEntry = entry;
-          const newMessage = {
-            id: getId(`${eventData.requestId}-message`),
-            type: eventData.payload.type,
-            data: eventData.payload.data,
-            timestamp: eventData.timestamp
-          };
-          const updatedEntry = {
-            ...sseEntry,
-            messages: [...sseEntry.messages, newMessage].slice(
-              -32
+          set({ isRecording });
+        },
+        setSelectedRequest: (requestId) => set({ selectedRequestId: requestId }),
+        clearRequests: () => set({
+          networkEntries: /* @__PURE__ */ new Map(),
+          websocketMessages: /* @__PURE__ */ new Map(),
+          selectedRequestId: null
+        }),
+        addOverride: (requestUrl, override) => {
+          const { overrides, _client } = get();
+          assert(!!_client, "Client is not set");
+          const newOverrides = new Map(overrides);
+          newOverrides.set(requestUrl, override);
+          _client.send("set-overrides", {
+            overrides: Array.from(newOverrides.entries())
+          });
+          set({ overrides: newOverrides });
+        },
+        clearOverride: (requestUrl) => {
+          const { overrides, _client } = get();
+          assert(!!_client, "Client is not set");
+          const newOverrides = new Map(overrides);
+          newOverrides.delete(requestUrl);
+          _client.send("set-overrides", {
+            overrides: Array.from(newOverrides.entries())
+          });
+          set({ overrides: newOverrides });
+        }
+      },
+      // Event handling
+      handleEvent: (eventType, data) => {
+        switch (eventType) {
+          case "request-sent": {
+            const eventData = data;
+            set((state) => {
+              const headersWithContentType = applyReactNativeRequestHeadersLogic(
+                eventData.request.headers,
+                eventData.request.postData
+              );
+              const requestContentType = getContentTypeMime(headersWithContentType) || "text/plain";
+              const entry = {
+                id: eventData.requestId,
+                type: "http",
+                timestamp: eventData.timestamp,
+                request: {
+                  url: eventData.request.url,
+                  method: eventData.request.method,
+                  headers: headersWithContentType,
+                  body: eventData.request.postData ? {
+                    type: requestContentType,
+                    data: eventData.request.postData
+                  } : void 0
+                },
+                status: "pending",
+                initiator: eventData.initiator,
+                resourceType: eventData.type
+              };
+              const newEntries = new Map(state.networkEntries);
+              newEntries.set(eventData.requestId, entry);
+              return { networkEntries: newEntries };
+            });
+            break;
+          }
+          case "response-received": {
+            const eventData = data;
+            set((state) => {
+              const entry = state.networkEntries.get(eventData.requestId);
+              if (!entry || entry.type !== "http") return state;
+              const httpEntry = entry;
+              const updatedEntry = {
+                ...httpEntry,
+                status: "loading",
+                response: eventData.response
+              };
+              const newEntries = new Map(state.networkEntries);
+              newEntries.set(eventData.requestId, updatedEntry);
+              return { networkEntries: newEntries };
+            });
+            break;
+          }
+          case "request-completed": {
+            const eventData = data;
+            set((state) => {
+              const entry = state.networkEntries.get(eventData.requestId);
+              if (!entry || entry.type !== "http") return state;
+              const httpEntry = entry;
+              const updatedEntry = {
+                ...httpEntry,
+                status: "finished",
+                duration: eventData.duration,
+                size: eventData.size,
+                ttfb: eventData.ttfb
+              };
+              const newEntries = new Map(state.networkEntries);
+              newEntries.set(eventData.requestId, updatedEntry);
+              return { networkEntries: newEntries };
+            });
+            break;
+          }
+          case "request-failed": {
+            const eventData = data;
+            set((state) => {
+              const entry = state.networkEntries.get(eventData.requestId);
+              if (!entry || entry.type !== "http") return state;
+              const httpEntry = entry;
+              const updatedEntry = {
+                ...httpEntry,
+                status: "failed",
+                error: eventData.error
+              };
+              const newEntries = new Map(state.networkEntries);
+              newEntries.set(eventData.requestId, updatedEntry);
+              return { networkEntries: newEntries };
+            });
+            break;
+          }
+          case "response-body": {
+            const eventData = data;
+            set((state) => {
+              var _a;
+              const entry = state.networkEntries.get(eventData.requestId);
+              if (!entry || entry.type !== "http") return state;
+              const httpEntry = entry;
+              const updatedEntry = {
+                ...httpEntry,
+                response: httpEntry.response ? {
+                  ...httpEntry.response,
+                  body: eventData.body ? {
+                    type: getContentTypeMime(
+                      ((_a = httpEntry.response) == null ? void 0 : _a.headers) ?? {}
+                    ) || "text/plain",
+                    data: eventData.body
+                  } : void 0
+                } : void 0
+              };
+              const newEntries = new Map(state.networkEntries);
+              newEntries.set(eventData.requestId, updatedEntry);
+              return { networkEntries: newEntries };
+            });
+            break;
+          }
+          case "websocket-connect": {
+            const eventData = data;
+            set((state) => {
+              const entry = {
+                id: `ws-${eventData.socketId}`,
+                type: "websocket",
+                timestamp: eventData.timestamp,
+                connection: {
+                  url: eventData.url,
+                  socketId: eventData.socketId,
+                  protocols: eventData.protocols || void 0,
+                  options: eventData.options
+                },
+                status: "connecting"
+              };
+              const newEntries = new Map(state.networkEntries);
+              newEntries.set(entry.id, entry);
+              const newMessages = new Map(state.websocketMessages);
+              newMessages.set(entry.id, []);
+              return {
+                networkEntries: newEntries,
+                websocketMessages: newMessages
+              };
+            });
+            break;
+          }
+          case "websocket-open": {
+            const eventData = data;
+            set((state) => {
+              const entry = state.networkEntries.get(
+                `ws-${eventData.socketId}`
+              );
+              if (!entry || entry.type !== "websocket") return state;
+              const wsEntry = entry;
+              const updatedEntry = {
+                ...wsEntry,
+                status: "open"
+              };
+              const newEntries = new Map(state.networkEntries);
+              newEntries.set(entry.id, updatedEntry);
+              return { networkEntries: newEntries };
+            });
+            break;
+          }
+          case "websocket-close": {
+            const eventData = data;
+            set((state) => {
+              const entry = state.networkEntries.get(
+                `ws-${eventData.socketId}`
+              );
+              if (!entry || entry.type !== "websocket") return state;
+              const wsEntry = entry;
+              const updatedEntry = {
+                ...wsEntry,
+                status: "closed",
+                closeCode: eventData.code,
+                closeReason: eventData.reason,
+                duration: eventData.timestamp - wsEntry.timestamp
+              };
+              const newEntries = new Map(state.networkEntries);
+              newEntries.set(entry.id, updatedEntry);
+              return { networkEntries: newEntries };
+            });
+            break;
+          }
+          case "websocket-message-sent": {
+            const eventData = data;
+            set((state) => {
+              const socketId = `ws-${eventData.socketId}`;
+              const currentMessages = state.websocketMessages.get(socketId) || [];
+              const message = {
+                id: getId(`${socketId}-message`),
+                direction: "sent",
+                data: eventData.data,
+                messageType: eventData.messageType,
+                timestamp: eventData.timestamp
+              };
+              const newMessages = new Map(state.websocketMessages);
+              newMessages.set(
+                socketId,
+                [...currentMessages, message].slice(
+                  -32
+                )
+              );
+              return { websocketMessages: newMessages };
+            });
+            break;
+          }
+          case "websocket-message-received": {
+            const eventData = data;
+            set((state) => {
+              const socketId = `ws-${eventData.socketId}`;
+              const currentMessages = state.websocketMessages.get(socketId) || [];
+              const message = {
+                id: getId(`${socketId}-message`),
+                direction: "received",
+                data: eventData.data,
+                messageType: eventData.messageType,
+                timestamp: eventData.timestamp
+              };
+              const newMessages = new Map(state.websocketMessages);
+              newMessages.set(
+                socketId,
+                [...currentMessages, message].slice(
+                  -32
+                )
+              );
+              return { websocketMessages: newMessages };
+            });
+            break;
+          }
+          case "websocket-error": {
+            const eventData = data;
+            set((state) => {
+              const entry = state.networkEntries.get(
+                `ws-${eventData.socketId}`
+              );
+              if (!entry || entry.type !== "websocket") return state;
+              const wsEntry = entry;
+              const updatedEntry = {
+                ...wsEntry,
+                status: "error",
+                error: eventData.error
+              };
+              const newEntries = new Map(state.networkEntries);
+              newEntries.set(entry.id, updatedEntry);
+              return { networkEntries: newEntries };
+            });
+            break;
+          }
+          case "websocket-connection-status-changed": {
+            const eventData = data;
+            set((state) => {
+              const entry = state.networkEntries.get(
+                `ws-${eventData.socketId}`
+              );
+              if (!entry || entry.type !== "websocket") return state;
+              const wsEntry = entry;
+              const updatedEntry = {
+                ...wsEntry,
+                status: eventData.status
+              };
+              const newEntries = new Map(state.networkEntries);
+              newEntries.set(entry.id, updatedEntry);
+              return { networkEntries: newEntries };
+            });
+            break;
+          }
+          case "sse-open": {
+            const eventData = data;
+            set((state) => {
+              const entry = state.networkEntries.get(eventData.requestId);
+              if (!entry || entry.type !== "http") return state;
+              const httpEntry = entry;
+              const sseEntry = {
+                ...httpEntry,
+                type: "sse",
+                // Change type from 'http' to 'sse'
+                status: "open",
+                // Update status
+                messages: [],
+                // Add SSE-specific field
+                response: eventData.response
+              };
+              const newEntries = new Map(state.networkEntries);
+              newEntries.set(eventData.requestId, sseEntry);
+              return { networkEntries: newEntries };
+            });
+            break;
+          }
+          case "sse-message": {
+            const eventData = data;
+            set((state) => {
+              const entry = state.networkEntries.get(eventData.requestId);
+              if (!entry || entry.type !== "sse") return state;
+              const sseEntry = entry;
+              const newMessage = {
+                id: getId(`${eventData.requestId}-message`),
+                type: eventData.payload.type,
+                data: eventData.payload.data,
+                timestamp: eventData.timestamp
+              };
+              const updatedEntry = {
+                ...sseEntry,
+                messages: [...sseEntry.messages, newMessage].slice(
+                  -32
+                )
+              };
+              const newEntries = new Map(state.networkEntries);
+              newEntries.set(eventData.requestId, updatedEntry);
+              return { networkEntries: newEntries };
+            });
+            break;
+          }
+          case "sse-error": {
+            const eventData = data;
+            set((state) => {
+              const entry = state.networkEntries.get(eventData.requestId);
+              if (!entry || entry.type !== "sse") return state;
+              const sseEntry = entry;
+              const updatedEntry = {
+                ...sseEntry,
+                status: "error",
+                error: eventData.error.message
+              };
+              const newEntries = new Map(state.networkEntries);
+              newEntries.set(eventData.requestId, updatedEntry);
+              return { networkEntries: newEntries };
+            });
+            break;
+          }
+          case "sse-close": {
+            const eventData = data;
+            set((state) => {
+              const entry = state.networkEntries.get(eventData.requestId);
+              if (!entry || entry.type !== "sse") return state;
+              const sseEntry = entry;
+              const updatedEntry = {
+                ...sseEntry,
+                status: "closed",
+                duration: eventData.timestamp - sseEntry.timestamp
+              };
+              const newEntries = new Map(state.networkEntries);
+              newEntries.set(eventData.requestId, updatedEntry);
+              return { networkEntries: newEntries };
+            });
+            break;
+          }
+        }
+      },
+      // Client management
+      client: {
+        setupClient: (client2) => {
+          const { handleEvent } = get();
+          const unsubscribeFunctions = [
+            client2.onMessage(
+              "request-sent",
+              (data) => handleEvent("request-sent", data)
+            ),
+            client2.onMessage(
+              "response-received",
+              (data) => handleEvent("response-received", data)
+            ),
+            client2.onMessage(
+              "request-completed",
+              (data) => handleEvent("request-completed", data)
+            ),
+            client2.onMessage(
+              "request-failed",
+              (data) => handleEvent("request-failed", data)
+            ),
+            client2.onMessage(
+              "response-body",
+              (data) => handleEvent("response-body", data)
+            ),
+            client2.onMessage(
+              "websocket-connect",
+              (data) => handleEvent("websocket-connect", data)
+            ),
+            client2.onMessage(
+              "websocket-open",
+              (data) => handleEvent("websocket-open", data)
+            ),
+            client2.onMessage(
+              "websocket-close",
+              (data) => handleEvent("websocket-close", data)
+            ),
+            client2.onMessage(
+              "websocket-message-sent",
+              (data) => handleEvent("websocket-message-sent", data)
+            ),
+            client2.onMessage(
+              "websocket-message-received",
+              (data) => handleEvent("websocket-message-received", data)
+            ),
+            client2.onMessage(
+              "websocket-error",
+              (data) => handleEvent("websocket-error", data)
+            ),
+            client2.onMessage(
+              "websocket-connection-status-changed",
+              (data) => handleEvent("websocket-connection-status-changed", data)
+            ),
+            client2.onMessage(
+              "sse-open",
+              (data) => handleEvent("sse-open", data)
+            ),
+            client2.onMessage(
+              "sse-message",
+              (data) => handleEvent("sse-message", data)
+            ),
+            client2.onMessage(
+              "sse-error",
+              (data) => handleEvent("sse-error", data)
+            ),
+            client2.onMessage(
+              "sse-close",
+              (data) => handleEvent("sse-close", data)
             )
-          };
-          const newEntries = new Map(state.networkEntries);
-          newEntries.set(eventData.requestId, updatedEntry);
-          return { networkEntries: newEntries };
-        });
-        break;
-      }
-      case "sse-error": {
-        const eventData = data;
-        set((state) => {
-          const entry = state.networkEntries.get(eventData.requestId);
-          if (!entry || entry.type !== "sse") return state;
-          const sseEntry = entry;
-          const updatedEntry = {
-            ...sseEntry,
-            status: "error",
-            error: eventData.error.message
-          };
-          const newEntries = new Map(state.networkEntries);
-          newEntries.set(eventData.requestId, updatedEntry);
-          return { networkEntries: newEntries };
-        });
-        break;
-      }
-      case "sse-close": {
-        const eventData = data;
-        set((state) => {
-          const entry = state.networkEntries.get(eventData.requestId);
-          if (!entry || entry.type !== "sse") return state;
-          const sseEntry = entry;
-          const updatedEntry = {
-            ...sseEntry,
-            status: "closed",
-            duration: eventData.timestamp - sseEntry.timestamp
-          };
-          const newEntries = new Map(state.networkEntries);
-          newEntries.set(eventData.requestId, updatedEntry);
-          return { networkEntries: newEntries };
-        });
-        break;
-      }
-    }
-  },
-  // Client management
-  client: {
-    setupClient: (client2) => {
-      const { handleEvent } = get();
-      const unsubscribeFunctions = [
-        client2.onMessage(
-          "request-sent",
-          (data) => handleEvent("request-sent", data)
-        ),
-        client2.onMessage(
-          "response-received",
-          (data) => handleEvent("response-received", data)
-        ),
-        client2.onMessage(
-          "request-completed",
-          (data) => handleEvent("request-completed", data)
-        ),
-        client2.onMessage(
-          "request-failed",
-          (data) => handleEvent("request-failed", data)
-        ),
-        client2.onMessage(
-          "response-body",
-          (data) => handleEvent("response-body", data)
-        ),
-        client2.onMessage(
-          "websocket-connect",
-          (data) => handleEvent("websocket-connect", data)
-        ),
-        client2.onMessage(
-          "websocket-open",
-          (data) => handleEvent("websocket-open", data)
-        ),
-        client2.onMessage(
-          "websocket-close",
-          (data) => handleEvent("websocket-close", data)
-        ),
-        client2.onMessage(
-          "websocket-message-sent",
-          (data) => handleEvent("websocket-message-sent", data)
-        ),
-        client2.onMessage(
-          "websocket-message-received",
-          (data) => handleEvent("websocket-message-received", data)
-        ),
-        client2.onMessage(
-          "websocket-error",
-          (data) => handleEvent("websocket-error", data)
-        ),
-        client2.onMessage(
-          "websocket-connection-status-changed",
-          (data) => handleEvent("websocket-connection-status-changed", data)
-        ),
-        client2.onMessage("sse-open", (data) => handleEvent("sse-open", data)),
-        client2.onMessage(
-          "sse-message",
-          (data) => handleEvent("sse-message", data)
-        ),
-        client2.onMessage(
-          "sse-error",
-          (data) => handleEvent("sse-error", data)
-        ),
-        client2.onMessage(
-          "sse-close",
-          (data) => handleEvent("sse-close", data)
-        )
-      ];
-      set({
-        _unsubscribeFunctions: unsubscribeFunctions,
-        _client: client2
-      });
-    },
-    cleanupClient: () => {
-      const { _unsubscribeFunctions, _client } = get();
-      if (_unsubscribeFunctions) {
-        _unsubscribeFunctions.forEach(
-          (unsubscribe) => unsubscribe.remove()
-        );
-      }
-      if (_client) {
-        _client.send("network-disable", {});
+          ];
+          set({
+            _unsubscribeFunctions: unsubscribeFunctions,
+            _client: client2
+          });
+        },
+        cleanupClient: () => {
+          const { _unsubscribeFunctions, _client } = get();
+          if (_unsubscribeFunctions) {
+            _unsubscribeFunctions.forEach(
+              (unsubscribe) => unsubscribe.remove()
+            );
+          }
+          if (_client) {
+            _client.send("network-disable", {});
+          }
+          set({
+            _unsubscribeFunctions: void 0,
+            _client: void 0
+          });
+        }
       }
-      set({
-        _unsubscribeFunctions: void 0,
-        _client: void 0
-      });
+    }),
+    {
+      name: "rozenite-network-activity-storage",
+      version: STORE_VERSION,
+      storage: createJSONStorage(() => localStorage, {
+        replacer: (key, value) => {
+          if (value instanceof Map) {
+            return {
+              _type: "map",
+              value: Array.from(value.entries())
+            };
+          }
+          return value;
+        },
+        reviver: (key, value) => {
+          if (typeof value === "object" && value !== null && value._type === "map") {
+            return new Map(value.value);
+          }
+          return value;
+        }
+      }),
+      partialize: (state) => ({ overrides: state.overrides })
+      // Persist only the overrides
     }
-  }
-}));
+  )
+);
 const store = createNetworkActivityStore();
 const TRACK_MEMO_SYMBOL = Symbol();
 const GET_ORIGINAL_SYMBOL = Symbol();
@@ -15998,6 +16258,9 @@ const useWebSocketMessages = (requestId) => {
     (state) => state.websocketMessages.get(requestId) || []
   );
 };
+const useOverrides = () => {
+  return useNetworkActivityStore((state) => state.overrides);
+};
 const Toolbar = () => {
   const actions = useNetworkActivityActions();
   const isRecording = useIsRecording();
@@ -18875,10 +19138,11 @@ const sortTime = (rowA, rowB, columnId) => {
   };
   return getNumericValue(a) - getNumericValue(b);
 };
-const processNetworkRequests = (processedRequests) => {
+const processNetworkRequests = (processedRequests, overrides) => {
   return processedRequests.map((request) => {
     const { domain, path } = extractDomainAndPath(request.name);
     const duration = request.duration || 0;
+    const hasOverride = overrides.has(request.name);
     return {
       id: request.id,
       name: generateName(request.name),
@@ -18889,7 +19153,8 @@ const processNetworkRequests = (processedRequests) => {
       size: isNumber(request.size) ? formatSize(request.size) : "—",
       time: formatDuration(duration),
       type: request.type,
-      startTime: formatStartTime(request.timestamp)
+      startTime: formatStartTime(request.timestamp),
+      hasOverride
     };
   });
 };
@@ -18903,14 +19168,10 @@ const columns$1 = [
   }),
   columnHelper$2.accessor("name", {
     header: "Name",
-    cell: ({ row, getValue: getValue2 }) => /* @__PURE__ */ jsxRuntimeExports.jsx(
-      "div",
-      {
-        className: "flex-1 min-w-0 truncate",
-        title: row.original.path,
-        children: getValue2()
-      }
-    ),
+    cell: ({ row, getValue: getValue2 }) => /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { className: "flex-1 min-w-0 truncate", title: row.original.path, children: [
+      getValue2(),
+      row.original.hasOverride && /* @__PURE__ */ jsxRuntimeExports.jsx("span", { className: "w-2 h-2 rounded-full bg-violet-300 ms-2 inline-block" })
+    ] }),
     sortingFn: "alphanumeric"
   }),
   columnHelper$2.accessor("status", {
@@ -18951,6 +19212,7 @@ const RequestList = ({ filter: filter2 }) => {
   const processedRequests = useProcessedRequests();
   const selectedRequestId = useSelectedRequestId();
   const [sorting, setSorting] = reactExports.useState([]);
+  const overrides = useOverrides();
   const filteredRequests = reactExports.useMemo(() => {
     return processedRequests.filter((request) => {
       if (!filter2.types.has(request.type)) {
@@ -18969,8 +19231,8 @@ const RequestList = ({ filter: filter2 }) => {
     });
   }, [processedRequests, filter2]);
   const requests = reactExports.useMemo(() => {
-    return processNetworkRequests(filteredRequests);
-  }, [filteredRequests]);
+    return processNetworkRequests(filteredRequests, overrides);
+  }, [filteredRequests, overrides]);
   const table = useReactTable({
     data: requests,
     columns: columns$1,
@@ -20584,7 +20846,8 @@ ScrollBar.displayName = ScrollAreaScrollbar.displayName;
 const Section = ({
   title,
   children,
-  collapsible = true
+  collapsible = true,
+  action
 }) => {
   const [isCollapsed, setIsCollapsed] = reactExports.useState(false);
   const isChildrenVisible = !collapsible || !isCollapsed;
@@ -20601,7 +20864,8 @@ const Section = ({
         tabIndex: collapsible ? 0 : -1,
         children: [
           collapsible && /* @__PURE__ */ jsxRuntimeExports.jsx("span", { className: cn("mr-2", { "rotate-90": !isCollapsed }), children: "▶" }),
-          /* @__PURE__ */ jsxRuntimeExports.jsx("span", { className: "font-medium", children: title })
+          /* @__PURE__ */ jsxRuntimeExports.jsx("span", { className: "font-medium me-auto", children: title }),
+          action
         ]
       }
     ),
@@ -29416,8 +29680,139 @@ const RequestTab = ({ selectedRequest }) => {
     !hasQueryParams && !requestBody && /* @__PURE__ */ jsxRuntimeExports.jsx("div", { className: "text-sm text-gray-400", children: "No request body or query params for this request" })
   ] }) });
 };
-const renderResponseBodySection = (children) => {
-  return /* @__PURE__ */ jsxRuntimeExports.jsx(Section, { title: "Response Body", collapsible: false, children: /* @__PURE__ */ jsxRuntimeExports.jsx("div", { className: "space-y-4", children }) });
+const CodeEditor = reactExports.forwardRef(
+  ({ data, onInput }, ref) => {
+    return /* @__PURE__ */ jsxRuntimeExports.jsx(
+      "pre",
+      {
+        ref,
+        contentEditable: true,
+        suppressContentEditableWarning: true,
+        className: "w-full text-sm font-mono text-gray-300 whitespace-pre-wrap bg-gray-800 p-3 rounded-md border border-gray-700 overflow-x-auto wrap-anywhere ring-offset-blue-500 focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2",
+        onInput,
+        children: data
+      }
+    );
+  }
+);
+CodeEditor.displayName = "CodeEditor";
+const OverrideResponse = ({
+  selectedRequest,
+  initialOverride,
+  onClear
+}) => {
+  var _a;
+  const actions = useNetworkActivityActions();
+  const [savedOverride, setSavedOverride] = reactExports.useState(initialOverride);
+  const [editedBody, setEditedBody] = reactExports.useState(
+    initialOverride == null ? void 0 : initialOverride.body
+  );
+  const [editedStatus, setEditedStatus] = reactExports.useState(
+    initialOverride == null ? void 0 : initialOverride.status
+  );
+  const responseEditorRef = reactExports.useRef(null);
+  const responseBody = (_a = selectedRequest.response) == null ? void 0 : _a.body;
+  const saveOverride = () => {
+    if (editedBody === void 0 && editedStatus === void 0) return;
+    const newOverrideData = {
+      body: editedBody,
+      status: editedStatus
+    };
+    setSavedOverride(newOverrideData);
+    actions.addOverride(selectedRequest.request.url, newOverrideData);
+  };
+  const clearOverride = () => {
+    setSavedOverride(void 0);
+    setEditedBody(void 0);
+    actions.clearOverride(selectedRequest.request.url);
+    onClear();
+  };
+  if (!responseBody || responseBody.data === null) {
+    return /* @__PURE__ */ jsxRuntimeExports.jsx("div", { className: "text-sm text-gray-400", children: "No response body available for this request" });
+  }
+  const { type } = responseBody;
+  const hasChanges = editedBody !== (savedOverride == null ? void 0 : savedOverride.body) || editedStatus !== (savedOverride == null ? void 0 : savedOverride.status);
+  const overrideActions = /* @__PURE__ */ jsxRuntimeExports.jsxs(jsxRuntimeExports.Fragment, { children: [
+    /* @__PURE__ */ jsxRuntimeExports.jsxs(
+      Button,
+      {
+        variant: "ghost",
+        size: "xs",
+        className: "text-violet-300 hover:text-violet-300 ms-2",
+        onClick: clearOverride,
+        children: [
+          /* @__PURE__ */ jsxRuntimeExports.jsx(CircleSlash2, { className: "h-2 w-2" }),
+          "Clear override"
+        ]
+      }
+    ),
+    /* @__PURE__ */ jsxRuntimeExports.jsxs(
+      Button,
+      {
+        variant: "ghost",
+        size: "xs",
+        className: "text-violet-300 hover:text-violet-300",
+        onClick: saveOverride,
+        disabled: !hasChanges,
+        children: [
+          /* @__PURE__ */ jsxRuntimeExports.jsx(Check, { className: "h-2 w-2" }),
+          hasChanges ? "Save override" : "Saved"
+        ]
+      }
+    )
+  ] });
+  if (savedOverride !== void 0) {
+    return /* @__PURE__ */ jsxRuntimeExports.jsx(
+      Section,
+      {
+        title: "Response Body",
+        collapsible: false,
+        action: overrideActions,
+        children: /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { className: "space-y-4", children: [
+          /* @__PURE__ */ jsxRuntimeExports.jsx(
+            KeyValueGrid,
+            {
+              items: [
+                {
+                  key: "Content-Type",
+                  value: type,
+                  valueClassName: "text-blue-400"
+                }
+              ]
+            }
+          ),
+          /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { className: "grid grid-cols-[minmax(7rem,25%)_minmax(3rem,1fr)] gap-x-2 gap-y-2 text-sm", children: [
+            /* @__PURE__ */ jsxRuntimeExports.jsx("span", { className: "text-gray-400 wrap-anywhere", children: "Status Code" }),
+            /* @__PURE__ */ jsxRuntimeExports.jsx(
+              "input",
+              {
+                type: "number",
+                value: editedStatus,
+                onChange: (e) => {
+                  setEditedStatus(parseInt(e.target.value));
+                },
+                className: "max-w-24 font-mono text-gray-300 whitespace-pre-wrap bg-gray-800 p-1 rounded-md border border-gray-700 overflow-x-auto wrap-anywhere ring-offset-blue-500 focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2"
+              }
+            )
+          ] }),
+          /* @__PURE__ */ jsxRuntimeExports.jsx(
+            CodeEditor,
+            {
+              data: savedOverride == null ? void 0 : savedOverride.body,
+              ref: responseEditorRef,
+              onInput: (e) => setEditedBody(e.currentTarget.innerText)
+            }
+          )
+        ] })
+      }
+    );
+  }
+};
+const RenderResponseBodySection = ({
+  children,
+  action
+}) => {
+  return /* @__PURE__ */ jsxRuntimeExports.jsx(Section, { title: "Response Body", collapsible: false, action, children: /* @__PURE__ */ jsxRuntimeExports.jsx("div", { className: "space-y-4", children }) });
 };
 const ResponseTab = ({
   selectedRequest,
@@ -29425,6 +29820,11 @@ const ResponseTab = ({
 }) => {
   var _a;
   const onRequestResponseBodyRef = reactExports.useRef(onRequestResponseBody);
+  const overrides = useOverrides();
+  const [initialOverride, setInitialOverride] = reactExports.useState(() => {
+    const override = overrides.get(selectedRequest.request.url);
+    return override;
+  });
   reactExports.useEffect(() => {
     onRequestResponseBodyRef.current = onRequestResponseBody;
   }, [onRequestResponseBody]);
@@ -29435,10 +29835,12 @@ const ResponseTab = ({
   }, [selectedRequest.id]);
   const responseBody = (_a = selectedRequest.response) == null ? void 0 : _a.body;
   const renderResponseBody = () => {
+    var _a2;
     if (!responseBody || responseBody.data === null) {
       return /* @__PURE__ */ jsxRuntimeExports.jsx("div", { className: "text-sm text-gray-400", children: "No response body available for this request" });
     }
     const { type, data } = responseBody;
+    const statusCode = (_a2 = selectedRequest.response) == null ? void 0 : _a2.status;
     const contentTypeGrid = /* @__PURE__ */ jsxRuntimeExports.jsx(
       KeyValueGrid,
       {
@@ -29451,6 +29853,32 @@ const ResponseTab = ({
         ]
       }
     );
+    const overrideAction = /* @__PURE__ */ jsxRuntimeExports.jsxs(
+      Button,
+      {
+        variant: "ghost",
+        size: "xs",
+        className: "text-violet-300 hover:text-violet-300",
+        onClick: () => setInitialOverride({
+          body: data,
+          status: statusCode
+        }),
+        children: [
+          /* @__PURE__ */ jsxRuntimeExports.jsx(Pencil, { className: "h-2 w-2" }),
+          "Override"
+        ]
+      }
+    );
+    if (initialOverride !== void 0) {
+      return /* @__PURE__ */ jsxRuntimeExports.jsx(
+        OverrideResponse,
+        {
+          selectedRequest,
+          initialOverride,
+          onClear: () => setInitialOverride(void 0)
+        }
+      );
+    }
     if (type.startsWith("application/json")) {
       let bodyContent;
       try {
@@ -29462,31 +29890,25 @@ const ResponseTab = ({
           /* @__PURE__ */ jsxRuntimeExports.jsx("div", { className: "text-xs text-gray-500 mt-1", children: "⚠️ Failed to parse as JSON, showing as raw text" })
         ] });
       }
-      return renderResponseBodySection(
-        /* @__PURE__ */ jsxRuntimeExports.jsxs(jsxRuntimeExports.Fragment, { children: [
-          contentTypeGrid,
-          bodyContent
-        ] })
-      );
+      return /* @__PURE__ */ jsxRuntimeExports.jsxs(RenderResponseBodySection, { action: overrideAction, children: [
+        contentTypeGrid,
+        bodyContent
+      ] });
     }
     if (type.startsWith("text/") || type.startsWith("application/xml") || type.startsWith("application/javascript")) {
-      return renderResponseBodySection(
-        /* @__PURE__ */ jsxRuntimeExports.jsxs(jsxRuntimeExports.Fragment, { children: [
-          contentTypeGrid,
-          /* @__PURE__ */ jsxRuntimeExports.jsx(CodeBlock, { children: data })
-        ] })
-      );
-    }
-    return renderResponseBodySection(
-      /* @__PURE__ */ jsxRuntimeExports.jsxs(jsxRuntimeExports.Fragment, { children: [
+      return /* @__PURE__ */ jsxRuntimeExports.jsxs(RenderResponseBodySection, { action: overrideAction, children: [
         contentTypeGrid,
-        /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { className: "text-sm text-gray-400", children: [
-          "Binary content not shown - ",
-          data.length,
-          " bytes"
-        ] })
+        /* @__PURE__ */ jsxRuntimeExports.jsx(CodeBlock, { children: data })
+      ] });
+    }
+    return /* @__PURE__ */ jsxRuntimeExports.jsxs(RenderResponseBodySection, { children: [
+      contentTypeGrid,
+      /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { className: "text-sm text-gray-400", children: [
+        "Binary content not shown - ",
+        data.length,
+        " bytes"
       ] })
-    );
+    ] });
   };
   return /* @__PURE__ */ jsxRuntimeExports.jsx(ScrollArea, { className: "h-full w-full", children: /* @__PURE__ */ jsxRuntimeExports.jsx("div", { className: "p-4", children: renderResponseBody() }) });
 };
@@ -30052,6 +30474,7 @@ const SidePanel = () => {
   const actions = useNetworkActivityActions();
   const selectedRequest = useSelectedRequest();
   const client2 = useNetworkActivityStore((state) => state._client);
+  const overrides = useOverrides();
   const onClose = () => {
     actions.setSelectedRequest(null);
   };
@@ -30072,6 +30495,8 @@ const SidePanel = () => {
   if (legacyEntry) {
     legacyNetworkEntries.set(legacyEntry.requestId, legacyEntry);
   }
+  const override = legacyEntry !== null ? overrides.get(legacyEntry.url) : null;
+  const hasResponseOverride = override && override.body ? true : false;
   const getTabsListTriggers = () => {
     if (httpDetails) {
       return /* @__PURE__ */ jsxRuntimeExports.jsxs(jsxRuntimeExports.Fragment, { children: [
@@ -30091,12 +30516,15 @@ const SidePanel = () => {
             children: "Request"
           }
         ),
-        /* @__PURE__ */ jsxRuntimeExports.jsx(
+        /* @__PURE__ */ jsxRuntimeExports.jsxs(
           TabsTrigger,
           {
             value: "response",
             className: "data-[state=active]:bg-gray-700",
-            children: "Response"
+            children: [
+              "Response",
+              hasResponseOverride && /* @__PURE__ */ jsxRuntimeExports.jsx("span", { className: "w-2 h-2 rounded-full bg-violet-300 ms-2 inline-block" })
+            ]
           }
         ),
         /* @__PURE__ */ jsxRuntimeExports.jsx(
@@ -30335,6 +30763,7 @@ const InspectorView = ({ client: client2 }) => {
   const actions = useNetworkActivityActions();
   const clientManagement = useNetworkActivityClientManagement();
   const hasSelectedRequest = useHasSelectedRequest();
+  const overrides = useOverrides();
   const [filter2, setFilter] = reactExports.useState({
     text: "",
     types: /* @__PURE__ */ new Set(["http", "websocket", "sse"])
@@ -30345,11 +30774,14 @@ const InspectorView = ({ client: client2 }) => {
     }
     clientManagement.setupClient(client2);
     actions.setRecording(true);
+    client2.send("set-overrides", {
+      overrides: Array.from(overrides.entries())
+    });
     return () => {
       actions.setRecording(false);
       clientManagement.cleanupClient();
     };
-  }, [client2, clientManagement, actions]);
+  }, [client2, clientManagement, actions, overrides]);
   return /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { className: "h-screen bg-gray-900 text-gray-100 flex flex-col", children: [
     /* @__PURE__ */ jsxRuntimeExports.jsx(Toolbar, {}),
     /* @__PURE__ */ jsxRuntimeExports.jsx(FilterBar, { filter: filter2, onFilterChange: setFilter }),