diff --git a/package.json b/package.json
index 4463a37..ad036ab 100644
--- a/package.json
+++ b/package.json
@@ -6,6 +6,8 @@
     "typecheck": "pnpm -r typecheck",
     "lint": "eslint --fix packages/*/src",
     "knip": "knip",
+    "test": "vitest run",
+    "test:watch": "vitest",
     "build": "caido-dev build",
     "watch": "caido-dev watch"
   },
@@ -20,7 +22,8 @@
     "postcss-prefixwrap": "1.51.0",
     "tailwindcss": "3.4.13",
     "tailwindcss-primeui": "0.3.4",
-    "typescript": "5.5.4"
+    "typescript": "5.5.4",
+    "vitest": "4.0.18"
   },
   "dependencies": {
     "@types/d3": "^7.4.3",
diff --git a/packages/backend/src/api/graphql.ts b/packages/backend/src/api/graphql.ts
index 07b407f..76ba2ca 100644
--- a/packages/backend/src/api/graphql.ts
+++ b/packages/backend/src/api/graphql.ts
@@ -1,7 +1,8 @@
 import type { SDK } from "caido:plugin";
-import type { GraphQLSchema, Result } from "shared";
+import type { GraphQLSchema, Result, SchemaImportResult } from "shared";
 
 import { GraphQLService } from "../services/graphql";
+import { parseSchemaFromFileContent } from "../services/graphql/schemaImporter";
 
 export async function testGraphQLEndpoint(
   sdk: SDK,
@@ -96,3 +97,23 @@ export async function getRequestInfo(
     };
   }
 }
+
+export function importSchemaFromFile(
+  _sdk: SDK,
+  fileContent: string,
+  fileName: string,
+): Result<SchemaImportResult & { fileName: string }> {
+  const result = parseSchemaFromFileContent(fileContent);
+
+  if (result.kind === "Error") {
+    return result;
+  }
+
+  return {
+    kind: "Ok",
+    value: {
+      ...result.value,
+      fileName,
+    },
+  };
+}
diff --git a/packages/backend/src/index.ts b/packages/backend/src/index.ts
index 5ffc09b..f13353c 100644
--- a/packages/backend/src/index.ts
+++ b/packages/backend/src/index.ts
@@ -9,6 +9,7 @@ import {
   getAttackStatus,
   getAttackTemplates,
   getRequestInfo,
+  importSchemaFromFile,
   startGraphQLAttacks,
   testGraphQLEndpoint,
   testGraphQLEndpointFromRequest,
@@ -30,6 +31,9 @@ export type {
   AttackFinding,
   AttackConfig,
   AttackSession,
+  DashboardActivity,
+  ExplorerSession,
+  SchemaImportResult,
 } from "shared";
 
 export { type BackendEvents } from "./types";
@@ -46,6 +50,7 @@ export type API = DefineAPI<{
   getAttackTemplates: typeof getAttackTemplates;
   createCaidoFinding: typeof createCaidoFinding;
   getRequestInfo: typeof getRequestInfo;
+  importSchemaFromFile: typeof importSchemaFromFile;
 }>;
 
 export function init(sdk: SDK<API>) {
@@ -63,6 +68,7 @@ export function init(sdk: SDK<API>) {
   sdk.api.register("getAttackTemplates", getAttackTemplates);
   sdk.api.register("createCaidoFinding", createCaidoFinding);
   sdk.api.register("getRequestInfo", getRequestInfo);
+  sdk.api.register("importSchemaFromFile", importSchemaFromFile);
 
   sdk.console.log("GraphQL Analyzer backend initialized");
 }
diff --git a/packages/backend/src/services/graphql/client.ts b/packages/backend/src/services/graphql/client.ts
index 46e0b15..622f98b 100644
--- a/packages/backend/src/services/graphql/client.ts
+++ b/packages/backend/src/services/graphql/client.ts
@@ -1,9 +1,17 @@
 import type { SDK } from "caido:plugin";
 import { RequestSpec } from "caido:utils";
-import type { GraphQLSchema, IntrospectionSchema, Result } from "shared";
+import type { GraphQLSchema, Result } from "shared";
 
 import { INTROSPECTION_QUERY } from "./introspection";
-import { parseIntrospectionResult } from "./parser";
+import {
+  mapHttpStatusToError,
+  mergeHeaders,
+  parseRawHttpRequest,
+} from "./requestUtils";
+import {
+  parseIntrospectionResponseBody,
+  parseQueryResponseBody,
+} from "./responseParser";
 
 export class GraphQLClient {
   constructor(private sdk: SDK) {}
@@ -37,82 +45,11 @@ export class GraphQLClient {
       }
 
       const originalRaw = originalRequest.getRaw().toText();
-      const lines = originalRaw.split(/\r?\n/);
-      const originalHeaders: Record<string, string> = {};
-      let originalBody = "";
+      const parsed = parseRawHttpRequest(originalRaw);
+      const originalHeaders = parsed.headers;
+      const originalBody = parsed.body;
 
-      let inHeaders = false;
-      let bodyStartIndex = -1;
-      for (let i = 0; i < lines.length; i++) {
-        const line = lines[i];
-        if (line === undefined) continue;
-
-        const trimmedLine = line.trim();
-
-        if (i === 0) {
-          inHeaders = true;
-          continue;
-        }
-
-        if (inHeaders === true && trimmedLine === "") {
-          bodyStartIndex = i + 1;
-          break;
-        }
-
-        if (
-          inHeaders === true &&
-          typeof trimmedLine === "string" &&
-          trimmedLine.includes(":")
-        ) {
-          const colonIndex = trimmedLine.indexOf(":");
-          const headerName = trimmedLine.substring(0, colonIndex).trim();
-          const headerValue = trimmedLine.substring(colonIndex + 1).trim();
-          if (
-            headerName !== "" &&
-            headerValue !== "" &&
-            headerName.toLowerCase() !== "content-length"
-          ) {
-            originalHeaders[headerName] = headerValue;
-          }
-        }
-      }
-
-      if (bodyStartIndex > 0 && bodyStartIndex < lines.length) {
-        originalBody = lines.slice(bodyStartIndex).join("\r\n").trim();
-      }
-
-      const headers: Record<string, string> = {
-        ...originalHeaders,
-        "Content-Type": "application/json",
-        Accept: "application/json",
-        "User-Agent": "Caido/GraphQL-Analyzer",
-      };
-
-      if (customHeaders && typeof customHeaders === "object") {
-        Object.entries(customHeaders).forEach(([key, value]) => {
-          if (
-            key &&
-            value &&
-            typeof key === "string" &&
-            typeof value === "string" &&
-            key.trim() &&
-            value.trim()
-          ) {
-            headers[key] = String(value);
-          }
-        });
-      }
-
-      for (const [key, value] of Object.entries(headers)) {
-        if (
-          typeof value !== "string" ||
-          value === "" ||
-          value === "null" ||
-          value === "undefined"
-        ) {
-          delete headers[key];
-        }
-      }
+      const headers = mergeHeaders(originalHeaders, customHeaders);
 
       const method = originalRequest.getMethod() || "POST";
 
@@ -207,38 +144,7 @@ export class GraphQLClient {
         return { kind: "Error", error: "Failed to extract host from URL" };
       }
 
-      const headers: Record<string, string> = {};
-
-      headers["Host"] = String(hostHeader);
-      headers["Content-Type"] = "application/json";
-      headers["Accept"] = "application/json";
-      headers["User-Agent"] = "Caido/GraphQL-Analyzer";
-
-      if (customHeaders && typeof customHeaders === "object") {
-        Object.entries(customHeaders).forEach(([key, value]) => {
-          if (
-            key &&
-            value &&
-            typeof key === "string" &&
-            typeof value === "string" &&
-            key.trim() &&
-            value.trim()
-          ) {
-            headers[key] = String(value);
-          }
-        });
-      }
-
-      for (const [key, value] of Object.entries(headers)) {
-        if (
-          typeof value !== "string" ||
-          value === "" ||
-          value === "null" ||
-          value === "undefined"
-        ) {
-          delete headers[key];
-        }
-      }
+      const headers = mergeHeaders({ Host: String(hostHeader) }, customHeaders);
 
       const requestBody = JSON.stringify({
         query: INTROSPECTION_QUERY,
@@ -285,119 +191,12 @@ export class GraphQLClient {
     const statusCode = result.response.getCode();
     const responseBody = result.response.getBody()?.toText() ?? "";
 
-    if (statusCode === 401) {
-      return {
-        kind: "Error",
-        error: `Authentication required (HTTP 401). Add Authorization, Cookie, or API key headers.`,
-      };
-    }
-
-    if (statusCode === 403) {
-      return {
-        kind: "Error",
-        error: `Access forbidden (HTTP 403). Your credentials lack required permissions.`,
-      };
-    }
-
-    if (statusCode === 404) {
-      return {
-        kind: "Error",
-        error: `Endpoint not found (HTTP 404). Verify the URL is correct.`,
-      };
-    }
-
-    if (statusCode === 405) {
-      return {
-        kind: "Error",
-        error: `Method not allowed (HTTP 405). This endpoint may not support POST requests.`,
-      };
+    const statusError = mapHttpStatusToError(statusCode, responseBody);
+    if (statusError !== undefined) {
+      return statusError;
     }
 
-    if (statusCode >= 500) {
-      return {
-        kind: "Error",
-        error: `Server error (HTTP ${statusCode}). The server is experiencing issues.`,
-      };
-    }
-
-    if (statusCode !== 200) {
-      const trimmed = responseBody.trim();
-      if (trimmed.startsWith("<!DOCTYPE") || trimmed.startsWith("<html")) {
-        return {
-          kind: "Error",
-          error: `Received HTML page (HTTP ${statusCode}). This may not be a GraphQL endpoint.`,
-        };
-      }
-      const preview = responseBody.substring(0, 150);
-      return {
-        kind: "Error",
-        error: `Unexpected response (HTTP ${statusCode}): ${preview}...`,
-      };
-    }
-
-    try {
-      const jsonResponse = JSON.parse(responseBody);
-
-      if (
-        Array.isArray(jsonResponse.errors) &&
-        jsonResponse.errors.length > 0
-      ) {
-        const introspectionDisabled = jsonResponse.errors.some(
-          (error: { message?: string }) => {
-            const message = error.message;
-            return (
-              typeof message === "string" &&
-              (message.toLowerCase().includes("introspection") ||
-                message.toLowerCase().includes("disabled") ||
-                message.toLowerCase().includes("not allowed"))
-            );
-          },
-        );
-
-        if (introspectionDisabled === true) {
-          return { kind: "Ok", value: { supportsIntrospection: false } };
-        }
-
-        const errorMessages = (
-          jsonResponse.errors as Array<{ message?: string }>
-        )
-          .map((e) => e.message ?? "Unknown error")
-          .join(", ");
-        return {
-          kind: "Error",
-          error: `GraphQL error: ${errorMessages}`,
-        };
-      }
-
-      if (
-        jsonResponse.data !== undefined &&
-        jsonResponse.data.__schema !== undefined
-      ) {
-        const schema = parseIntrospectionResult(
-          jsonResponse.data.__schema as IntrospectionSchema,
-        );
-        (
-          schema as GraphQLSchema & { rawIntrospection?: unknown }
-        ).rawIntrospection = jsonResponse.data;
-        return { kind: "Ok", value: { supportsIntrospection: true, schema } };
-      }
-
-      if (jsonResponse.data !== undefined) {
-        return {
-          kind: "Error",
-          error:
-            "GraphQL endpoint responded but introspection is disabled or not available.",
-        };
-      }
-
-      return {
-        kind: "Error",
-        error: "Endpoint returned JSON but it's not a valid GraphQL response.",
-      };
-    } catch {
-      const preview = responseBody.substring(0, 100);
-      return { kind: "Error", error: `Invalid JSON response: ${preview}...` };
-    }
+    return parseIntrospectionResponseBody(responseBody);
   }
 
   async executeQuery(
@@ -432,15 +231,7 @@ export class GraphQLClient {
       }
 
       const body = result.response.getBody()?.toText() ?? "";
-      try {
-        const json = JSON.parse(body);
-        return { kind: "Ok", value: json };
-      } catch {
-        return {
-          kind: "Error",
-          error: "Invalid JSON response",
-        };
-      }
+      return parseQueryResponseBody(body);
     } catch (error) {
       return {
         kind: "Error",
diff --git a/packages/backend/src/services/graphql/requestUtils.test.ts b/packages/backend/src/services/graphql/requestUtils.test.ts
new file mode 100644
index 0000000..1206d1c
--- /dev/null
+++ b/packages/backend/src/services/graphql/requestUtils.test.ts
@@ -0,0 +1,209 @@
+import { describe, expect, it } from "vitest";
+
+import {
+  mapHttpStatusToError,
+  mergeHeaders,
+  parseRawHttpRequest,
+} from "./requestUtils";
+
+describe("parseRawHttpRequest", () => {
+  it("parses a standard POST request with headers and body", () => {
+    const raw = [
+      "POST /graphql HTTP/1.1",
+      "Host: example.com",
+      "Content-Type: application/json",
+      "Authorization: Bearer token123",
+      "Content-Length: 42",
+      "",
+      '{"query":"{ __typename }"}',
+    ].join("\r\n");
+
+    const result = parseRawHttpRequest(raw);
+
+    expect(result.headers["Host"]).toBe("example.com");
+    expect(result.headers["Content-Type"]).toBe("application/json");
+    expect(result.headers["Authorization"]).toBe("Bearer token123");
+    expect(result.headers["Content-Length"]).toBeUndefined();
+    expect(result.body).toBe('{"query":"{ __typename }"}');
+  });
+
+  it("parses request with LF line endings", () => {
+    const raw = [
+      "POST /graphql HTTP/1.1",
+      "Host: example.com",
+      "Cookie: session=abc",
+      "",
+      '{"query":"{ users { id } }"}',
+    ].join("\n");
+
+    const result = parseRawHttpRequest(raw);
+    expect(result.headers["Host"]).toBe("example.com");
+    expect(result.headers["Cookie"]).toBe("session=abc");
+    expect(result.body).toBe('{"query":"{ users { id } }"}');
+  });
+
+  it("returns empty body for request without body", () => {
+    const raw = ["GET /graphql HTTP/1.1", "Host: example.com", ""].join("\r\n");
+
+    const result = parseRawHttpRequest(raw);
+    expect(result.headers["Host"]).toBe("example.com");
+    expect(result.body).toBe("");
+  });
+
+  it("handles headers with colons in value", () => {
+    const raw = [
+      "POST /graphql HTTP/1.1",
+      "Host: example.com:8080",
+      "Authorization: Basic dXNlcjpwYXNz",
+      "",
+      "{}",
+    ].join("\r\n");
+
+    const result = parseRawHttpRequest(raw);
+    expect(result.headers["Host"]).toBe("example.com:8080");
+    expect(result.headers["Authorization"]).toBe("Basic dXNlcjpwYXNz");
+  });
+
+  it("handles multiline body", () => {
+    const body = JSON.stringify(
+      { query: "{ users { id name email } }" },
+      undefined,
+      2,
+    );
+    const raw = [
+      "POST /graphql HTTP/1.1",
+      "Host: example.com",
+      "Content-Type: application/json",
+      "",
+      body,
+    ].join("\r\n");
+
+    const result = parseRawHttpRequest(raw);
+    expect(JSON.parse(result.body)).toEqual({
+      query: "{ users { id name email } }",
+    });
+  });
+
+  it("handles empty raw input", () => {
+    const result = parseRawHttpRequest("");
+    expect(result.headers).toEqual({});
+    expect(result.body).toBe("");
+  });
+});
+
+describe("mergeHeaders", () => {
+  it("adds default headers to original headers", () => {
+    const result = mergeHeaders({ Host: "example.com" });
+    expect(result["Host"]).toBe("example.com");
+    expect(result["Content-Type"]).toBe("application/json");
+    expect(result["Accept"]).toBe("application/json");
+    expect(result["User-Agent"]).toBe("Caido/GraphQL-Analyzer");
+  });
+
+  it("custom headers override defaults", () => {
+    const result = mergeHeaders(
+      { Host: "example.com" },
+      { Authorization: "Bearer token", "User-Agent": "Custom-Agent" },
+    );
+    expect(result["Authorization"]).toBe("Bearer token");
+    expect(result["User-Agent"]).toBe("Custom-Agent");
+  });
+
+  it("filters out null/undefined/empty string values", () => {
+    const result = mergeHeaders({
+      Host: "example.com",
+      "X-Bad-Null": "null",
+      "X-Bad-Undefined": "undefined",
+      "X-Bad-Empty": "",
+    });
+    expect(result["Host"]).toBe("example.com");
+    expect(result["X-Bad-Null"]).toBeUndefined();
+    expect(result["X-Bad-Undefined"]).toBeUndefined();
+    expect(result["X-Bad-Empty"]).toBeUndefined();
+  });
+
+  it("ignores custom headers with empty key or value", () => {
+    const result = mergeHeaders(
+      { Host: "example.com" },
+      { "": "value", "X-Valid": "ok", "X-Empty": "   " },
+    );
+    expect(result[""]).toBeUndefined();
+    expect(result["X-Valid"]).toBe("ok");
+  });
+
+  it("works with no custom headers", () => {
+    const result = mergeHeaders({ Host: "example.com" });
+    expect(Object.keys(result).length).toBeGreaterThanOrEqual(4);
+  });
+});
+
+describe("mapHttpStatusToError", () => {
+  it("returns auth error for 401", () => {
+    const result = mapHttpStatusToError(401, "");
+    expect(result).toBeDefined();
+    expect(result?.kind).toBe("Error");
+    if (result?.kind === "Error") {
+      expect(result.error).toContain("401");
+      expect(result.error).toContain("Authentication");
+    }
+  });
+
+  it("returns forbidden error for 403", () => {
+    const result = mapHttpStatusToError(403, "");
+    expect(result?.kind).toBe("Error");
+    if (result?.kind === "Error") {
+      expect(result.error).toContain("403");
+    }
+  });
+
+  it("returns not found error for 404", () => {
+    const result = mapHttpStatusToError(404, "");
+    expect(result?.kind).toBe("Error");
+    if (result?.kind === "Error") {
+      expect(result.error).toContain("404");
+    }
+  });
+
+  it("returns method not allowed for 405", () => {
+    const result = mapHttpStatusToError(405, "");
+    expect(result?.kind).toBe("Error");
+    if (result?.kind === "Error") {
+      expect(result.error).toContain("405");
+    }
+  });
+
+  it("returns server error for 500+", () => {
+    for (const code of [500, 502, 503]) {
+      const result = mapHttpStatusToError(code, "");
+      expect(result?.kind).toBe("Error");
+      if (result?.kind === "Error") {
+        expect(result.error).toContain(String(code));
+      }
+    }
+  });
+
+  it("detects HTML page responses", () => {
+    const result = mapHttpStatusToError(
+      302,
+      "<!DOCTYPE html><html><body>Redirect</body></html>",
+    );
+    expect(result?.kind).toBe("Error");
+    if (result?.kind === "Error") {
+      expect(result.error).toContain("HTML page");
+    }
+  });
+
+  it("returns preview for unknown non-200 status", () => {
+    const result = mapHttpStatusToError(418, "I'm a teapot");
+    expect(result?.kind).toBe("Error");
+    if (result?.kind === "Error") {
+      expect(result.error).toContain("418");
+      expect(result.error).toContain("teapot");
+    }
+  });
+
+  it("returns undefined for 200 (no error)", () => {
+    const result = mapHttpStatusToError(200, "");
+    expect(result).toBeUndefined();
+  });
+});
diff --git a/packages/backend/src/services/graphql/requestUtils.ts b/packages/backend/src/services/graphql/requestUtils.ts
new file mode 100644
index 0000000..5585fdf
--- /dev/null
+++ b/packages/backend/src/services/graphql/requestUtils.ts
@@ -0,0 +1,146 @@
+type ParsedRawRequest = {
+  headers: Record<string, string>;
+  body: string;
+};
+
+export function parseRawHttpRequest(rawText: string): ParsedRawRequest {
+  const lines = rawText.split(/\r?\n/);
+  const headers: Record<string, string> = {};
+  let body = "";
+
+  let inHeaders = false;
+  let bodyStartIndex = -1;
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (line === undefined) continue;
+
+    const trimmedLine = line.trim();
+
+    if (i === 0) {
+      inHeaders = true;
+      continue;
+    }
+
+    if (inHeaders === true && trimmedLine === "") {
+      bodyStartIndex = i + 1;
+      break;
+    }
+
+    if (
+      inHeaders === true &&
+      typeof trimmedLine === "string" &&
+      trimmedLine.includes(":")
+    ) {
+      const colonIndex = trimmedLine.indexOf(":");
+      const headerName = trimmedLine.substring(0, colonIndex).trim();
+      const headerValue = trimmedLine.substring(colonIndex + 1).trim();
+      if (
+        headerName !== "" &&
+        headerValue !== "" &&
+        headerName.toLowerCase() !== "content-length"
+      ) {
+        headers[headerName] = headerValue;
+      }
+    }
+  }
+
+  if (bodyStartIndex > 0 && bodyStartIndex < lines.length) {
+    body = lines.slice(bodyStartIndex).join("\r\n").trim();
+  }
+
+  return { headers, body };
+}
+
+export function mergeHeaders(
+  originalHeaders: Record<string, string>,
+  customHeaders?: Record<string, string>,
+): Record<string, string> {
+  const headers: Record<string, string> = {
+    ...originalHeaders,
+    "Content-Type": "application/json",
+    Accept: "application/json",
+    "User-Agent": "Caido/GraphQL-Analyzer",
+  };
+
+  if (customHeaders !== undefined && typeof customHeaders === "object") {
+    Object.entries(customHeaders).forEach(([key, value]) => {
+      if (key.trim() !== "" && value.trim() !== "") {
+        headers[key] = value;
+      }
+    });
+  }
+
+  for (const [key, value] of Object.entries(headers)) {
+    if (
+      typeof value !== "string" ||
+      value === "" ||
+      value === "null" ||
+      value === "undefined"
+    ) {
+      delete headers[key];
+    }
+  }
+
+  return headers;
+}
+
+export function mapHttpStatusToError(
+  statusCode: number,
+  responseBody: string,
+): { kind: "Error"; error: string } | undefined {
+  if (statusCode === 401) {
+    return {
+      kind: "Error",
+      error:
+        "Authentication required (HTTP 401). Add Authorization, Cookie, or API key headers.",
+    };
+  }
+
+  if (statusCode === 403) {
+    return {
+      kind: "Error",
+      error:
+        "Access forbidden (HTTP 403). Your credentials lack required permissions.",
+    };
+  }
+
+  if (statusCode === 404) {
+    return {
+      kind: "Error",
+      error: "Endpoint not found (HTTP 404). Verify the URL is correct.",
+    };
+  }
+
+  if (statusCode === 405) {
+    return {
+      kind: "Error",
+      error:
+        "Method not allowed (HTTP 405). This endpoint may not support POST requests.",
+    };
+  }
+
+  if (statusCode >= 500) {
+    return {
+      kind: "Error",
+      error: `Server error (HTTP ${statusCode}). The server is experiencing issues.`,
+    };
+  }
+
+  if (statusCode !== 200) {
+    const trimmed = responseBody.trim();
+    if (trimmed.startsWith("<!DOCTYPE") || trimmed.startsWith("<html")) {
+      return {
+        kind: "Error",
+        error: `Received HTML page (HTTP ${statusCode}). This may not be a GraphQL endpoint.`,
+      };
+    }
+    const preview = responseBody.substring(0, 150);
+    return {
+      kind: "Error",
+      error: `Unexpected response (HTTP ${statusCode}): ${preview}...`,
+    };
+  }
+
+  return undefined;
+}
diff --git a/packages/backend/src/services/graphql/responseParser.test.ts b/packages/backend/src/services/graphql/responseParser.test.ts
new file mode 100644
index 0000000..09da473
--- /dev/null
+++ b/packages/backend/src/services/graphql/responseParser.test.ts
@@ -0,0 +1,172 @@
+import { describe, expect, it } from "vitest";
+
+import {
+  parseIntrospectionResponseBody,
+  parseQueryResponseBody,
+  unwrapBatchedResponse,
+} from "./responseParser";
+import { minimalIntrospectionSchema } from "./schemaImporter/fixtures/minimalSchema";
+
+describe("unwrapBatchedResponse", () => {
+  it("returns the first element when given an array", () => {
+    const batched = [{ data: { __typename: "Query" } }];
+    expect(unwrapBatchedResponse(batched)).toEqual({
+      data: { __typename: "Query" },
+    });
+  });
+
+  it("returns the object as-is when not an array", () => {
+    const standard = { data: { __typename: "Query" } };
+    expect(unwrapBatchedResponse(standard)).toEqual(standard);
+  });
+
+  it("returns empty array as-is", () => {
+    expect(unwrapBatchedResponse([])).toEqual([]);
+  });
+
+  it("handles null/undefined", () => {
+    expect(unwrapBatchedResponse(undefined)).toBeUndefined();
+  });
+});
+
+describe("parseIntrospectionResponseBody", () => {
+  const standardBody = JSON.stringify({
+    data: { __schema: minimalIntrospectionSchema },
+  });
+
+  const batchedBody = JSON.stringify([
+    { data: { __schema: minimalIntrospectionSchema } },
+  ]);
+
+  it("parses standard introspection response", () => {
+    const result = parseIntrospectionResponseBody(standardBody);
+    expect(result.kind).toBe("Ok");
+    if (result.kind === "Ok") {
+      expect(result.value.supportsIntrospection).toBe(true);
+      expect(result.value.schema).toBeDefined();
+      expect(result.value.schema?.queries.length).toBeGreaterThan(0);
+    }
+  });
+
+  it("parses batched introspection response", () => {
+    const result = parseIntrospectionResponseBody(batchedBody);
+    expect(result.kind).toBe("Ok");
+    if (result.kind === "Ok") {
+      expect(result.value.supportsIntrospection).toBe(true);
+      expect(result.value.schema).toBeDefined();
+      expect(result.value.schema?.queries.length).toBeGreaterThan(0);
+    }
+  });
+
+  it("produces identical schemas for standard and batched responses", () => {
+    const standardResult = parseIntrospectionResponseBody(standardBody);
+    const batchedResult = parseIntrospectionResponseBody(batchedBody);
+
+    expect(standardResult.kind).toBe("Ok");
+    expect(batchedResult.kind).toBe("Ok");
+
+    if (standardResult.kind === "Ok" && batchedResult.kind === "Ok") {
+      expect(batchedResult.value.schema?.queries).toEqual(
+        standardResult.value.schema?.queries,
+      );
+      expect(batchedResult.value.schema?.mutations).toEqual(
+        standardResult.value.schema?.mutations,
+      );
+      expect(batchedResult.value.schema?.types).toEqual(
+        standardResult.value.schema?.types,
+      );
+    }
+  });
+
+  it("detects introspection disabled errors", () => {
+    const body = JSON.stringify({
+      errors: [{ message: "Introspection is not allowed" }],
+    });
+    const result = parseIntrospectionResponseBody(body);
+    expect(result.kind).toBe("Ok");
+    if (result.kind === "Ok") {
+      expect(result.value.supportsIntrospection).toBe(false);
+    }
+  });
+
+  it("detects introspection disabled in batched error response", () => {
+    const body = JSON.stringify([
+      { errors: [{ message: "Introspection is disabled" }] },
+    ]);
+    const result = parseIntrospectionResponseBody(body);
+    expect(result.kind).toBe("Ok");
+    if (result.kind === "Ok") {
+      expect(result.value.supportsIntrospection).toBe(false);
+    }
+  });
+
+  it("returns GraphQL error for non-introspection errors", () => {
+    const body = JSON.stringify({
+      errors: [{ message: "Syntax error in query" }],
+    });
+    const result = parseIntrospectionResponseBody(body);
+    expect(result.kind).toBe("Error");
+    if (result.kind === "Error") {
+      expect(result.error).toContain("Syntax error in query");
+    }
+  });
+
+  it("returns error for data without __schema", () => {
+    const body = JSON.stringify({ data: { users: [] } });
+    const result = parseIntrospectionResponseBody(body);
+    expect(result.kind).toBe("Error");
+    if (result.kind === "Error") {
+      expect(result.error).toContain("introspection is disabled");
+    }
+  });
+
+  it("returns error for non-GraphQL JSON", () => {
+    const body = JSON.stringify({ status: "ok" });
+    const result = parseIntrospectionResponseBody(body);
+    expect(result.kind).toBe("Error");
+    if (result.kind === "Error") {
+      expect(result.error).toContain("not a valid GraphQL response");
+    }
+  });
+
+  it("returns error for invalid JSON", () => {
+    const result = parseIntrospectionResponseBody("not-json");
+    expect(result.kind).toBe("Error");
+    if (result.kind === "Error") {
+      expect(result.error).toContain("Invalid JSON response");
+    }
+  });
+
+  it("returns error for empty string", () => {
+    const result = parseIntrospectionResponseBody("");
+    expect(result.kind).toBe("Error");
+  });
+});
+
+describe("parseQueryResponseBody", () => {
+  it("parses standard query response", () => {
+    const body = JSON.stringify({ data: { users: [{ id: "1" }] } });
+    const result = parseQueryResponseBody(body);
+    expect(result.kind).toBe("Ok");
+    if (result.kind === "Ok") {
+      expect(result.value).toEqual({ data: { users: [{ id: "1" }] } });
+    }
+  });
+
+  it("unwraps batched query response", () => {
+    const body = JSON.stringify([
+      { data: { users: [{ id: "1" }] } },
+      { data: { posts: [] } },
+    ]);
+    const result = parseQueryResponseBody(body);
+    expect(result.kind).toBe("Ok");
+    if (result.kind === "Ok") {
+      expect(result.value).toEqual({ data: { users: [{ id: "1" }] } });
+    }
+  });
+
+  it("returns error for invalid JSON", () => {
+    const result = parseQueryResponseBody("<html>not json</html>");
+    expect(result.kind).toBe("Error");
+  });
+});
diff --git a/packages/backend/src/services/graphql/responseParser.ts b/packages/backend/src/services/graphql/responseParser.ts
new file mode 100644
index 0000000..c932c8d
--- /dev/null
+++ b/packages/backend/src/services/graphql/responseParser.ts
@@ -0,0 +1,98 @@
+import type { GraphQLSchema, IntrospectionSchema, Result } from "shared";
+
+import { parseIntrospectionResult } from "./parser";
+
+type IntrospectionResult = {
+  supportsIntrospection: boolean;
+  schema?: GraphQLSchema;
+};
+
+export function unwrapBatchedResponse(parsed: unknown): unknown {
+  if (Array.isArray(parsed) && parsed.length > 0) {
+    return parsed[0];
+  }
+  return parsed;
+}
+
+export function parseIntrospectionResponseBody(
+  responseBody: string,
+): Result<IntrospectionResult> {
+  try {
+    const parsed = JSON.parse(responseBody);
+    const jsonResponse = unwrapBatchedResponse(parsed) as Record<
+      string,
+      unknown
+    >;
+
+    if (Array.isArray(jsonResponse.errors) && jsonResponse.errors.length > 0) {
+      const introspectionDisabled = jsonResponse.errors.some(
+        (error: { message?: string }) => {
+          const message = error.message;
+          return (
+            typeof message === "string" &&
+            (message.toLowerCase().includes("introspection") ||
+              message.toLowerCase().includes("disabled") ||
+              message.toLowerCase().includes("not allowed"))
+          );
+        },
+      );
+
+      if (introspectionDisabled === true) {
+        return { kind: "Ok", value: { supportsIntrospection: false } };
+      }
+
+      const errorMessages = (jsonResponse.errors as Array<{ message?: string }>)
+        .map((e) => e.message ?? "Unknown error")
+        .join(", ");
+      return {
+        kind: "Error",
+        error: `GraphQL error: ${errorMessages}`,
+      };
+    }
+
+    if (
+      jsonResponse.data !== undefined &&
+      (jsonResponse.data as Record<string, unknown>).__schema !== undefined
+    ) {
+      const schema = parseIntrospectionResult(
+        (jsonResponse.data as Record<string, unknown>)
+          .__schema as IntrospectionSchema,
+      );
+      (
+        schema as GraphQLSchema & { rawIntrospection?: unknown }
+      ).rawIntrospection = jsonResponse.data;
+      return { kind: "Ok", value: { supportsIntrospection: true, schema } };
+    }
+
+    if (jsonResponse.data !== undefined) {
+      return {
+        kind: "Error",
+        error:
+          "GraphQL endpoint responded but introspection is disabled or not available.",
+      };
+    }
+
+    return {
+      kind: "Error",
+      error: "Endpoint returned JSON but it's not a valid GraphQL response.",
+    };
+  } catch {
+    const preview = responseBody.substring(0, 100);
+    return { kind: "Error", error: `Invalid JSON response: ${preview}...` };
+  }
+}
+
+export function parseQueryResponseBody(
+  responseBody: string,
+): Result<Record<string, unknown>> {
+  try {
+    const parsed = JSON.parse(responseBody);
+    const json = unwrapBatchedResponse(parsed);
+    return { kind: "Ok", value: json as Record<string, unknown> };
+  } catch {
+    return {
+      kind: "Error",
+      error: "Invalid JSON response",
+    };
+  }
+}
diff --git a/packages/backend/src/services/graphql/schemaImporter/detection.test.ts b/packages/backend/src/services/graphql/schemaImporter/detection.test.ts
new file mode 100644
index 0000000..1bcc805
--- /dev/null
+++ b/packages/backend/src/services/graphql/schemaImporter/detection.test.ts
@@ -0,0 +1,59 @@
+import { describe, expect, it } from "vitest";
+
+import { detectSchemaFormat } from "./detection";
+import { minimalIntrospectionSchema } from "./fixtures/minimalSchema";
+
+describe("detectSchemaFormat", () => {
+  it("detects wrapped introspection format: { data: { __schema: ... } }", () => {
+    const data = { data: { __schema: minimalIntrospectionSchema } };
+    const result = detectSchemaFormat(data);
+    expect(result.format).toBe("introspection-wrapped");
+    expect(result.schema).toBeDefined();
+    expect(result.error).toBeUndefined();
+  });
+
+  it("detects unwrapped introspection format: { __schema: ... }", () => {
+    const data = { __schema: minimalIntrospectionSchema };
+    const result = detectSchemaFormat(data);
+    expect(result.format).toBe("introspection-unwrapped");
+    expect(result.schema).toBeDefined();
+    expect(result.error).toBeUndefined();
+  });
+
+  it("detects direct schema object format", () => {
+    const result = detectSchemaFormat(minimalIntrospectionSchema);
+    expect(result.format).toBe("introspection-direct");
+    expect(result.schema).toBeDefined();
+    expect(result.error).toBeUndefined();
+  });
+
+  it("returns unknown for unrelated JSON object", () => {
+    const result = detectSchemaFormat({ name: "not a schema", items: [] });
+    expect(result.format).toBe("unknown");
+    expect(result.schema).toBeUndefined();
+    expect(result.error).toBeDefined();
+  });
+
+  it("returns unknown for null input", () => {
+    const result = detectSchemaFormat(null);
+    expect(result.format).toBe("unknown");
+    expect(result.error).toBe("Input is not a valid object");
+  });
+
+  it("returns unknown for a primitive value", () => {
+    const result = detectSchemaFormat("just a string" as unknown);
+    expect(result.format).toBe("unknown");
+  });
+
+  it("returns unknown for an empty object", () => {
+    const result = detectSchemaFormat({});
+    expect(result.format).toBe("unknown");
+  });
+
+  it("rejects __schema that has no types array", () => {
+    const result = detectSchemaFormat({
+      __schema: { queryType: { name: "Query" } },
+    });
+    expect(result.format).toBe("unknown");
+  });
+});
diff --git a/packages/backend/src/services/graphql/schemaImporter/detection.ts b/packages/backend/src/services/graphql/schemaImporter/detection.ts
new file mode 100644
index 0000000..11a1328
--- /dev/null
+++ b/packages/backend/src/services/graphql/schemaImporter/detection.ts
@@ -0,0 +1,77 @@
+import type { IntrospectionSchema } from "shared";
+
+export type SchemaFormat =
+  | "introspection-wrapped"
+  | "introspection-unwrapped"
+  | "introspection-direct"
+  | "unknown";
+
+export type DetectionResult = {
+  format: SchemaFormat;
+  schema: IntrospectionSchema | undefined;
+  error: string | undefined;
+};
+
+export function detectSchemaFormat(data: unknown): DetectionResult {
+  if (data === undefined || data === null || typeof data !== "object") {
+    return {
+      format: "unknown",
+      schema: undefined,
+      error: "Input is not a valid object",
+    };
+  }
+
+  const obj = data as Record<string, unknown>;
+
+  if (isWrappedIntrospection(obj)) {
+    const dataObj = obj.data as Record<string, unknown>;
+    const schema = dataObj.__schema as IntrospectionSchema;
+    return { format: "introspection-wrapped", schema, error: undefined };
+  }
+
+  if (isUnwrappedIntrospection(obj)) {
+    const schema = obj.__schema as IntrospectionSchema;
+    return { format: "introspection-unwrapped", schema, error: undefined };
+  }
+  if (isDirectSchemaObject(obj)) {
+    const schema = obj as unknown as IntrospectionSchema;
+    return { format: "introspection-direct", schema, error: undefined };
+  }
+
+  return {
+    format: "unknown",
+    schema: undefined,
+    error:
+      "JSON does not match any known GraphQL introspection format. " +
+      'Expected one of: { "data": { "__schema": ... } }, ' +
+      '{ "__schema": ... }, or a direct schema object with "queryType" and "types".',
+  };
+}
+
+function isWrappedIntrospection(obj: Record<string, unknown>): boolean {
+  if (
+    obj.data === undefined ||
+    obj.data === null ||
+    typeof obj.data !== "object"
+  ) {
+    return false;
+  }
+  const dataObj = obj.data as Record<string, unknown>;
+  return hasSchemaShape(dataObj.__schema);
+}
+
+function isUnwrappedIntrospection(obj: Record<string, unknown>): boolean {
+  return hasSchemaShape(obj.__schema);
+}
+
+function isDirectSchemaObject(obj: Record<string, unknown>): boolean {
+  return Array.isArray(obj.types) && obj.types.length > 0;
+}
+
+function hasSchemaShape(value: unknown): boolean {
+  if (value === undefined || value === null || typeof value !== "object") {
+    return false;
+  }
+  const schema = value as Record<string, unknown>;
+  return Array.isArray(schema.types);
+}
diff --git a/packages/backend/src/services/graphql/schemaImporter/fixtures/minimalSchema.ts b/packages/backend/src/services/graphql/schemaImporter/fixtures/minimalSchema.ts
new file mode 100644
index 0000000..1c5ae97
--- /dev/null
+++ b/packages/backend/src/services/graphql/schemaImporter/fixtures/minimalSchema.ts
@@ -0,0 +1,234 @@
+export const minimalIntrospectionSchema = {
+  queryType: { name: "Query" },
+  mutationType: { name: "Mutation" },
+  subscriptionType: null,
+  types: [
+    {
+      kind: "OBJECT",
+      name: "Query",
+      description: "Root query type",
+      fields: [
+        {
+          name: "user",
+          description: "Get a user by ID",
+          args: [
+            {
+              name: "id",
+              description: null,
+              type: {
+                kind: "NON_NULL",
+                name: null,
+                ofType: { kind: "SCALAR", name: "ID", ofType: null },
+              },
+              defaultValue: null,
+            },
+          ],
+          type: { kind: "OBJECT", name: "User", ofType: null },
+          isDeprecated: false,
+          deprecationReason: null,
+        },
+        {
+          name: "users",
+          description: "List all users",
+          args: [],
+          type: {
+            kind: "LIST",
+            name: null,
+            ofType: { kind: "OBJECT", name: "User", ofType: null },
+          },
+          isDeprecated: false,
+          deprecationReason: null,
+        },
+      ],
+      inputFields: null,
+      interfaces: [],
+      enumValues: null,
+      possibleTypes: null,
+    },
+    {
+      kind: "OBJECT",
+      name: "Mutation",
+      description: "Root mutation type",
+      fields: [
+        {
+          name: "createUser",
+          description: "Create a new user",
+          args: [
+            {
+              name: "name",
+              description: null,
+              type: {
+                kind: "NON_NULL",
+                name: null,
+                ofType: { kind: "SCALAR", name: "String", ofType: null },
+              },
+              defaultValue: null,
+            },
+            {
+              name: "email",
+              description: null,
+              type: {
+                kind: "NON_NULL",
+                name: null,
+                ofType: { kind: "SCALAR", name: "String", ofType: null },
+              },
+              defaultValue: null,
+            },
+          ],
+          type: { kind: "OBJECT", name: "User", ofType: null },
+          isDeprecated: false,
+          deprecationReason: null,
+        },
+      ],
+      inputFields: null,
+      interfaces: [],
+      enumValues: null,
+      possibleTypes: null,
+    },
+    {
+      kind: "OBJECT",
+      name: "User",
+      description: "A user in the system",
+      fields: [
+        {
+          name: "id",
+          description: null,
+          args: [],
+          type: {
+            kind: "NON_NULL",
+            name: null,
+            ofType: { kind: "SCALAR", name: "ID", ofType: null },
+          },
+          isDeprecated: false,
+          deprecationReason: null,
+        },
+        {
+          name: "name",
+          description: null,
+          args: [],
+          type: { kind: "SCALAR", name: "String", ofType: null },
+          isDeprecated: false,
+          deprecationReason: null,
+        },
+        {
+          name: "email",
+          description: null,
+          args: [],
+          type: { kind: "SCALAR", name: "String", ofType: null },
+          isDeprecated: false,
+          deprecationReason: null,
+        },
+        {
+          name: "role",
+          description: null,
+          args: [],
+          type: { kind: "ENUM", name: "Role", ofType: null },
+          isDeprecated: false,
+          deprecationReason: null,
+        },
+      ],
+      inputFields: null,
+      interfaces: [{ kind: "INTERFACE", name: "Node", ofType: null }],
+      enumValues: null,
+      possibleTypes: null,
+    },
+    {
+      kind: "ENUM",
+      name: "Role",
+      description: "User roles",
+      fields: null,
+      inputFields: null,
+      interfaces: null,
+      enumValues: [
+        {
+          name: "ADMIN",
+          description: "Administrator",
+          isDeprecated: false,
+          deprecationReason: null,
+        },
+        {
+          name: "USER",
+          description: "Regular user",
+          isDeprecated: false,
+          deprecationReason: null,
+        },
+      ],
+      possibleTypes: null,
+    },
+    {
+      kind: "INTERFACE",
+      name: "Node",
+      description: "An object with an ID",
+      fields: [
+        {
+          name: "id",
+          description: null,
+          args: [],
+          type: {
+            kind: "NON_NULL",
+            name: null,
+            ofType: { kind: "SCALAR", name: "ID", ofType: null },
+          },
+          isDeprecated: false,
+          deprecationReason: null,
+        },
+      ],
+      inputFields: null,
+      interfaces: null,
+      enumValues: null,
+      possibleTypes: [{ kind: "OBJECT", name: "User", ofType: null }],
+    },
+    {
+      kind: "SCALAR",
+      name: "String",
+      description: "Built-in String scalar",
+      fields: null,
+      inputFields: null,
+      interfaces: null,
+      enumValues: null,
+      possibleTypes: null,
+    },
+    {
+      kind: "SCALAR",
+      name: "ID",
+      description: "Built-in ID scalar",
+      fields: null,
+      inputFields: null,
+      interfaces: null,
+      enumValues: null,
+      possibleTypes: null,
+    },
+    {
+      kind: "SCALAR",
+      name: "Boolean",
+      description: "Built-in Boolean scalar",
+      fields: null,
+      inputFields: null,
+      interfaces: null,
+      enumValues: null,
+      possibleTypes: null,
+    },
+    // Internal types (should be filtered out by parser)
+    {
+      kind: "OBJECT",
+      name: "__Schema",
+      description: null,
+      fields: [],
+      inputFields: null,
+      interfaces: [],
+      enumValues: null,
+      possibleTypes: null,
+    },
+    {
+      kind: "OBJECT",
+      name: "__Type",
+      description: null,
+      fields: [],
+      inputFields: null,
+      interfaces: [],
+      enumValues: null,
+      possibleTypes: null,
+    },
+  ],
+  directives: [],
+};
diff --git a/packages/backend/src/services/graphql/schemaImporter/index.test.ts b/packages/backend/src/services/graphql/schemaImporter/index.test.ts
new file mode 100644
index 0000000..01e03fa
--- /dev/null
+++ b/packages/backend/src/services/graphql/schemaImporter/index.test.ts
@@ -0,0 +1,142 @@
+import { describe, expect, it } from "vitest";
+
+import { minimalIntrospectionSchema } from "./fixtures/minimalSchema";
+
+import { parseSchemaFromFileContent } from "./index";
+
+describe("parseSchemaFromFileContent", () => {
+  it("parses wrapped introspection JSON", () => {
+    const content = JSON.stringify({
+      data: { __schema: minimalIntrospectionSchema },
+    });
+    const result = parseSchemaFromFileContent(content);
+    expect(result.kind).toBe("Ok");
+    if (result.kind === "Ok") {
+      expect(result.value.format).toBe("introspection-wrapped");
+      expect(result.value.schema.queries).toHaveLength(2);
+      expect(result.value.schema.mutations).toHaveLength(1);
+    }
+  });
+
+  it("parses unwrapped introspection JSON", () => {
+    const content = JSON.stringify({
+      __schema: minimalIntrospectionSchema,
+    });
+    const result = parseSchemaFromFileContent(content);
+    expect(result.kind).toBe("Ok");
+    if (result.kind === "Ok") {
+      expect(result.value.format).toBe("introspection-unwrapped");
+      expect(result.value.schema.queries).toHaveLength(2);
+    }
+  });
+
+  it("parses direct schema object JSON", () => {
+    const content = JSON.stringify(minimalIntrospectionSchema);
+    const result = parseSchemaFromFileContent(content);
+    expect(result.kind).toBe("Ok");
+    if (result.kind === "Ok") {
+      expect(result.value.format).toBe("introspection-direct");
+      expect(result.value.schema.queries).toHaveLength(2);
+    }
+  });
+
+  it("returns error for empty content", () => {
+    const result = parseSchemaFromFileContent("");
+    expect(result.kind).toBe("Error");
+  });
+
+  it("returns error for invalid JSON", () => {
+    const result = parseSchemaFromFileContent("not json at all");
+    expect(result.kind).toBe("Error");
+    if (result.kind === "Error") {
+      expect(result.error).toContain("Invalid JSON");
+    }
+  });
+
+  it("returns error for valid JSON that is not a schema", () => {
+    const result = parseSchemaFromFileContent('{"users": [1, 2, 3]}');
+    expect(result.kind).toBe("Error");
+  });
+
+  it("correctly populates schema types", () => {
+    const content = JSON.stringify({
+      data: { __schema: minimalIntrospectionSchema },
+    });
+    const result = parseSchemaFromFileContent(content);
+    expect(result.kind).toBe("Ok");
+    if (result.kind === "Ok") {
+      const schema = result.value.schema;
+
+      // Queries
+      expect(schema.queries.map((q) => q.name)).toEqual(["user", "users"]);
+
+      // Mutations
+      expect(schema.mutations.map((m) => m.name)).toEqual(["createUser"]);
+
+      // Subscriptions (none in fixture)
+      expect(schema.subscriptions).toHaveLength(0);
+
+      // Custom types (User only, not Query/Mutation/internal)
+      expect(schema.types.map((t) => t.name)).toContain("User");
+      expect(schema.types.map((t) => t.name)).not.toContain("Query");
+      expect(schema.types.map((t) => t.name)).not.toContain("__Schema");
+
+      // Enums
+      expect(schema.enums.map((e) => e.name)).toContain("Role");
+      expect(
+        schema.enums.find((e) => e.name === "Role")?.values.map((v) => v.name),
+      ).toEqual(["ADMIN", "USER"]);
+
+      // Interfaces
+      expect(schema.interfaces.map((i) => i.name)).toContain("Node");
+    }
+  });
+
+  it("generates points of interest for sensitive fields", () => {
+    const content = JSON.stringify({
+      data: { __schema: minimalIntrospectionSchema },
+    });
+    const result = parseSchemaFromFileContent(content);
+    expect(result.kind).toBe("Ok");
+    if (result.kind === "Ok") {
+      expect(result.value.schema.pointsOfInterest).toBeDefined();
+      expect(Array.isArray(result.value.schema.pointsOfInterest)).toBe(true);
+    }
+  });
+
+  it("parses field arguments correctly", () => {
+    const content = JSON.stringify({
+      data: { __schema: minimalIntrospectionSchema },
+    });
+    const result = parseSchemaFromFileContent(content);
+    expect(result.kind).toBe("Ok");
+    if (result.kind === "Ok") {
+      const userQuery = result.value.schema.queries.find(
+        (q) => q.name === "user",
+      );
+      expect(userQuery).toBeDefined();
+      expect(userQuery?.args).toHaveLength(1);
+      expect(userQuery?.args[0]?.name).toBe("id");
+      expect(userQuery?.args[0]?.type).toBe("ID!");
+    }
+  });
+
+  it("formats type references correctly", () => {
+    const content = JSON.stringify({
+      data: { __schema: minimalIntrospectionSchema },
+    });
+    const result = parseSchemaFromFileContent(content);
+    expect(result.kind).toBe("Ok");
+    if (result.kind === "Ok") {
+      const usersQuery = result.value.schema.queries.find(
+        (q) => q.name === "users",
+      );
+      expect(usersQuery?.type).toBe("[User]");
+
+      const userQuery = result.value.schema.queries.find(
+        (q) => q.name === "user",
+      );
+      expect(userQuery?.type).toBe("User");
+    }
+  });
+});
diff --git a/packages/backend/src/services/graphql/schemaImporter/index.ts b/packages/backend/src/services/graphql/schemaImporter/index.ts
new file mode 100644
index 0000000..c594391
--- /dev/null
+++ b/packages/backend/src/services/graphql/schemaImporter/index.ts
@@ -0,0 +1,41 @@
+import type { Result, SchemaImportResult } from "shared";
+
+import { parseIntrospectionResult } from "../parser";
+
+import { detectSchemaFormat } from "./detection";
+import { parseJsonContent } from "./jsonParser";
+
+export function parseSchemaFromFileContent(
+  content: string,
+): Result<SchemaImportResult> {
+  const jsonResult = parseJsonContent(content);
+  if (jsonResult.kind === "Error") {
+    return jsonResult;
+  }
+
+  const detection = detectSchemaFormat(jsonResult.value);
+
+  if (detection.schema === undefined) {
+    return {
+      kind: "Error",
+      error: detection.error ?? "Failed to detect schema format",
+    };
+  }
+
+  try {
+    const schema = parseIntrospectionResult(detection.schema);
+    return {
+      kind: "Ok",
+      value: {
+        schema,
+        format: detection.format,
+      },
+    };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return {
+      kind: "Error",
+      error: `Failed to parse introspection schema: ${message}`,
+    };
+  }
+}
diff --git a/packages/backend/src/services/graphql/schemaImporter/jsonParser.test.ts b/packages/backend/src/services/graphql/schemaImporter/jsonParser.test.ts
new file mode 100644
index 0000000..9b98959
--- /dev/null
+++ b/packages/backend/src/services/graphql/schemaImporter/jsonParser.test.ts
@@ -0,0 +1,37 @@
+import { describe, expect, it } from "vitest";
+
+import { parseJsonContent } from "./jsonParser";
+
+describe("parseJsonContent", () => {
+  it("parses valid JSON", () => {
+    const result = parseJsonContent('{"key": "value"}');
+    expect(result.kind).toBe("Ok");
+    if (result.kind === "Ok") {
+      expect(result.value).toEqual({ key: "value" });
+    }
+  });
+
+  it("returns error for empty string", () => {
+    const result = parseJsonContent("");
+    expect(result.kind).toBe("Error");
+    if (result.kind === "Error") {
+      expect(result.error).toBe("File is empty");
+    }
+  });
+
+  it("returns error for whitespace-only string", () => {
+    const result = parseJsonContent("   \n\t  ");
+    expect(result.kind).toBe("Error");
+    if (result.kind === "Error") {
+      expect(result.error).toBe("File is empty");
+    }
+  });
+
+  it("returns error for invalid JSON", () => {
+    const result = parseJsonContent("{ broken json }");
+    expect(result.kind).toBe("Error");
+    if (result.kind === "Error") {
+      expect(result.error).toContain("Invalid JSON");
+    }
+  });
+});
diff --git a/packages/backend/src/services/graphql/schemaImporter/jsonParser.ts b/packages/backend/src/services/graphql/schemaImporter/jsonParser.ts
new file mode 100644
index 0000000..f33d8a1
--- /dev/null
+++ b/packages/backend/src/services/graphql/schemaImporter/jsonParser.ts
@@ -0,0 +1,20 @@
+import type { Result } from "shared";
+
+export function parseJsonContent(content: string): Result<unknown> {
+  const trimmed = content.trim();
+
+  if (trimmed === "") {
+    return { kind: "Error", error: "File is empty" };
+  }
+
+  try {
+    const parsed: unknown = JSON.parse(trimmed);
+    return { kind: "Ok", value: parsed };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return {
+      kind: "Error",
+      error: `Invalid JSON: ${message}`,
+    };
+  }
+}
diff --git a/packages/frontend/src/components/Explorer/CodePanel.vue b/packages/frontend/src/components/Explorer/CodePanel.vue
index 2887b7b..c76b678 100644
--- a/packages/frontend/src/components/Explorer/CodePanel.vue
+++ b/packages/frontend/src/components/Explorer/CodePanel.vue
@@ -1,5 +1,6 @@
 <script setup lang="ts">
 import Button from "primevue/button";
+import { computed } from "vue";
 
 import type { ExplorerSession } from "./useSessions";
 
@@ -21,6 +22,10 @@ const emit = defineEmits<{
   sendToAttacker: [];
 }>();
 
+const isFileImport = computed(
+  () => props.selectedSession?.sourceType === "file-import",
+);
+
 const copyToClipboard = async () => {
   if (props.selectedCode !== "") {
     try {
@@ -84,12 +89,17 @@ const sendToAttacker = async () => {
         </div>
         <div class="flex gap-2">
           <Button
-            v-tooltip="'Send to Attacker'"
+            v-tooltip="
+              isFileImport
+                ? 'Cannot attack imported schemas (no endpoint)'
+                : 'Send to Attacker'
+            "
             icon="fas fa-shield-alt"
             size="small"
             text
             severity="danger"
             class="text-xs"
+            :disabled="isFileImport"
             @click="sendToAttacker"
           />
           <Button
diff --git a/packages/frontend/src/components/Explorer/useSessions.ts b/packages/frontend/src/components/Explorer/useSessions.ts
index 102bea6..a79bcdf 100644
--- a/packages/frontend/src/components/Explorer/useSessions.ts
+++ b/packages/frontend/src/components/Explorer/useSessions.ts
@@ -1,18 +1,9 @@
-import type { GraphQLSchema } from "shared";
+import type { ExplorerSession } from "shared";
 import { computed, ref } from "vue";
 
 import { useSDK } from "@/plugins/sdk";
 
-export type ExplorerSession = {
-  id: string;
-  title: string;
-  url: string;
-  schema?: GraphQLSchema;
-  supportsIntrospection: boolean;
-  createdAt: Date;
-  status: string;
-  requestId?: string;
-};
+export type { ExplorerSession };
 
 export const useSessions = () => {
   const sdk = useSDK();
diff --git a/packages/frontend/src/components/Voyager/types.ts b/packages/frontend/src/components/Voyager/types.ts
index 2dd909b..88533fe 100644
--- a/packages/frontend/src/components/Voyager/types.ts
+++ b/packages/frontend/src/components/Voyager/types.ts
@@ -1,4 +1,6 @@
-import type { GraphQLField, GraphQLSchema } from "shared";
+import type { ExplorerSession, GraphQLField } from "shared";
+
+export type { ExplorerSession };
 
 export type D3Node = {
   id: number;
@@ -29,16 +31,6 @@ export type NavItem = {
   fieldData?: unknown;
 };
 
-export type ExplorerSession = {
-  id: string;
-  title: string;
-  url: string;
-  schema?: GraphQLSchema;
-  supportsIntrospection: boolean;
-  createdAt: Date;
-  status: string;
-};
-
 export const LAYOUT = {
   ROOT_SPACING: 80,
   COLUMN_SPACING: 150,
diff --git a/packages/frontend/src/components/dashboard/Container.vue b/packages/frontend/src/components/dashboard/Container.vue
index a118c0d..bee233c 100644
--- a/packages/frontend/src/components/dashboard/Container.vue
+++ b/packages/frontend/src/components/dashboard/Container.vue
@@ -1,11 +1,15 @@
 <script setup lang="ts">
-import { onMounted } from "vue";
+import { onMounted, ref } from "vue";
 
 import Header from "./Header.vue";
 import HeadersForm from "./HeadersForm.vue";
+import ImportSchemaDialog from "./ImportSchemaDialog.vue";
 import RecentActivity from "./RecentActivity.vue";
 import ScanForm from "./ScanForm.vue";
 import { useScanning } from "./useScanning";
+import { useSchemaImport } from "./useSchemaImport";
+
+defineOptions({ name: "DashboardContainer" });
 
 const props = defineProps<{
   navigateTo?: (
@@ -27,6 +31,23 @@ const {
   deleteAllData,
 } = useScanning(props.navigateTo);
 
+const { importSchemaFile } = useSchemaImport(
+  props.navigateTo,
+  loadRecentSessions,
+);
+
+const showImportDialog = ref(false);
+
+const handleImport = async (data: {
+  fileContent: string;
+  fileName: string;
+}) => {
+  const success = await importSchemaFile(data.fileContent, data.fileName);
+  if (success) {
+    showImportDialog.value = false;
+  }
+};
+
 onMounted(() => {
   loadRecentSessions();
 });
@@ -34,7 +55,7 @@ onMounted(() => {
 
 <template>
   <div class="flex flex-col h-full gap-1 overflow-hidden">
-    <Header />
+    <Header @import-schema="showImportDialog = true" />
 
     <div class="flex gap-2 flex-1 min-h-0">
       <div class="flex-1 flex flex-col gap-2">
@@ -64,5 +85,10 @@ onMounted(() => {
         @delete-all-data="deleteAllData"
       />
     </div>
+
+    <ImportSchemaDialog
+      v-model:visible="showImportDialog"
+      @import="handleImport"
+    />
   </div>
 </template>
diff --git a/packages/frontend/src/components/dashboard/Header.vue b/packages/frontend/src/components/dashboard/Header.vue
index c901b83..2327875 100644
--- a/packages/frontend/src/components/dashboard/Header.vue
+++ b/packages/frontend/src/components/dashboard/Header.vue
@@ -1,5 +1,12 @@
 <script setup lang="ts">
+import Button from "primevue/button";
 import Card from "primevue/card";
+
+defineOptions({ name: "DashboardHeader" });
+
+defineEmits<{
+  (e: "import-schema"): void;
+}>();
 </script>
 
 <template>
@@ -19,6 +26,14 @@ import Card from "primevue/card";
             information and security insights.
           </p>
         </div>
+        <Button
+          label="Import Schema"
+          icon="fas fa-file-import"
+          severity="secondary"
+          outlined
+          size="small"
+          @click="$emit('import-schema')"
+        />
       </div>
     </template>
   </Card>
diff --git a/packages/frontend/src/components/dashboard/ImportSchemaDialog.vue b/packages/frontend/src/components/dashboard/ImportSchemaDialog.vue
new file mode 100644
index 0000000..316090c
--- /dev/null
+++ b/packages/frontend/src/components/dashboard/ImportSchemaDialog.vue
@@ -0,0 +1,259 @@
+<script setup lang="ts">
+import Button from "primevue/button";
+import Dialog from "primevue/dialog";
+import { computed, ref } from "vue";
+
+import { useSDK } from "@/plugins/sdk";
+
+defineOptions({ name: "ImportSchemaDialog" });
+
+const props = defineProps<{
+  visible: boolean;
+}>();
+
+const emit = defineEmits<{
+  (e: "update:visible", value: boolean): void;
+  (e: "import", data: { fileContent: string; fileName: string }): void;
+}>();
+
+const sdk = useSDK();
+
+const selectedFile = ref<File | undefined>(undefined);
+const isDraggingOver = ref(false);
+const isImporting = ref(false);
+const fileInputRef = ref<HTMLInputElement | undefined>(undefined);
+
+const triggerFileInput = () => {
+  fileInputRef.value?.click();
+};
+
+const isVisible = computed({
+  get: () => props.visible,
+  set: (value) => emit("update:visible", value),
+});
+
+const acceptedExtensions = ".json";
+
+const handleFileSelect = (event: Event) => {
+  const input = event.target as HTMLInputElement;
+  if (input.files !== null && input.files.length > 0) {
+    const file = input.files[0];
+    if (file !== undefined) {
+      selectedFile.value = file;
+    }
+  }
+};
+
+const handleDrop = (event: DragEvent) => {
+  event.preventDefault();
+  isDraggingOver.value = false;
+
+  if (
+    event.dataTransfer?.files !== undefined &&
+    event.dataTransfer.files.length > 0
+  ) {
+    const file = event.dataTransfer.files[0];
+    if (file !== undefined) {
+      selectedFile.value = file;
+    }
+  }
+};
+
+const handleDragOver = (event: DragEvent) => {
+  event.preventDefault();
+  isDraggingOver.value = true;
+};
+
+const handleDragLeave = () => {
+  isDraggingOver.value = false;
+};
+
+const clearFile = () => {
+  selectedFile.value = undefined;
+};
+
+const formatFileSize = (bytes: number): string => {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+};
+
+const handleImport = async () => {
+  if (selectedFile.value === undefined) {
+    sdk.window.showToast("Please select a file first", { variant: "warning" });
+    return;
+  }
+
+  isImporting.value = true;
+
+  try {
+    const content = await readFileContent(selectedFile.value);
+    emit("import", {
+      fileContent: content,
+      fileName: selectedFile.value.name,
+    });
+  } catch (err) {
+    const message = err instanceof Error ? err.message : "Unknown error";
+    sdk.window.showToast(`Failed to read file: ${message}`, {
+      variant: "error",
+    });
+  } finally {
+    isImporting.value = false;
+  }
+};
+
+const readFileContent = (file: File): Promise<string> => {
+  return new Promise((resolve, reject) => {
+    const reader = new FileReader();
+    reader.onload = () => {
+      if (typeof reader.result === "string") {
+        resolve(reader.result);
+      } else {
+        reject(new Error("Failed to read file as text"));
+      }
+    };
+    reader.onerror = () => {
+      reject(new Error("File read error"));
+    };
+    reader.readAsText(file);
+  });
+};
+
+const resetAndClose = () => {
+  selectedFile.value = undefined;
+  isImporting.value = false;
+  isVisible.value = false;
+};
+</script>
+
+<template>
+  <Dialog
+    v-model:visible="isVisible"
+    modal
+    :style="{ width: '520px' }"
+    :closable="!isImporting"
+    :pt="{
+      root: { class: 'p-0 rounded-lg overflow-hidden' },
+      header: {
+        class:
+          'p-4 border-b border-surface-700 bg-surface-800 flex items-center justify-between',
+      },
+      content: { class: 'p-4 bg-surface-900' },
+      footer: {
+        class:
+          'p-4 border-t border-surface-700 flex justify-end gap-2 bg-surface-800',
+      },
+      closeButton: {
+        class:
+          'text-surface-300 hover:text-surface-100 w-8 h-8 flex items-center justify-center',
+      },
+      closeButtonIcon: { class: 'text-surface-300 text-lg' },
+    }"
+    @hide="resetAndClose"
+  >
+    <template #header>
+      <div class="flex items-center gap-2">
+        <i class="fas fa-file-import text-primary-400"></i>
+        <span class="text-lg font-semibold text-surface-100"
+          >Import Schema</span
+        >
+      </div>
+    </template>
+
+    <div class="space-y-4">
+      <p class="text-sm text-surface-300">
+        Import a GraphQL introspection JSON file to explore the schema in
+        Explorer and Voyager.
+      </p>
+
+      <div
+        :class="{
+          'border-2 border-dashed rounded-lg p-6 text-center cursor-pointer transition-all duration-200': true,
+          'border-primary-400 bg-primary-900/20': isDraggingOver,
+          'border-green-500 bg-green-900/10':
+            !isDraggingOver && selectedFile !== undefined,
+          'border-surface-600 hover:border-surface-400 bg-surface-800':
+            !isDraggingOver && selectedFile === undefined,
+        }"
+        @drop="handleDrop"
+        @dragover="handleDragOver"
+        @dragleave="handleDragLeave"
+        @click="triggerFileInput"
+      >
+        <input
+          ref="fileInputRef"
+          type="file"
+          :accept="acceptedExtensions"
+          class="hidden"
+          @change="handleFileSelect"
+        />
+
+        <div v-if="selectedFile === undefined">
+          <i class="fas fa-cloud-upload-alt text-3xl text-surface-400 mb-3"></i>
+          <div class="text-sm font-medium text-surface-200 mb-1">
+            Drop a JSON file here or click to browse
+          </div>
+          <div class="text-xs text-surface-500">
+            Supports introspection query results (.json)
+          </div>
+        </div>
+
+        <div v-else>
+          <div class="flex items-center justify-center gap-3">
+            <i class="fas fa-file-code text-2xl text-green-400"></i>
+            <div class="text-left">
+              <div class="text-sm font-medium text-surface-100">
+                {{ selectedFile.name }}
+              </div>
+              <div class="text-xs text-surface-400">
+                {{ formatFileSize(selectedFile.size) }}
+              </div>
+            </div>
+            <Button
+              v-tooltip="'Remove file'"
+              icon="fas fa-times"
+              severity="danger"
+              size="small"
+              text
+              @click.stop="clearFile"
+            />
+          </div>
+        </div>
+      </div>
+
+      <div
+        class="text-xs text-surface-500 border border-surface-700 rounded p-3 bg-surface-800"
+      >
+        <div class="flex items-center gap-2 mb-2 text-surface-300 font-medium">
+          <i class="fas fa-info-circle"></i>
+          <span>Supported format</span>
+        </div>
+        <div class="space-y-1">
+          <div>
+            <strong>JSON Introspection</strong> - the result of running an
+            introspection query against a GraphQL endpoint.
+          </div>
+        </div>
+      </div>
+    </div>
+
+    <template #footer>
+      <Button
+        label="Cancel"
+        severity="secondary"
+        outlined
+        size="small"
+        :disabled="isImporting"
+        @click="resetAndClose"
+      />
+      <Button
+        label="Import"
+        icon="fas fa-file-import"
+        size="small"
+        :loading="isImporting"
+        :disabled="selectedFile === undefined"
+        @click="handleImport"
+      />
+    </template>
+  </Dialog>
+</template>
diff --git a/packages/frontend/src/components/dashboard/RecentActivity.vue b/packages/frontend/src/components/dashboard/RecentActivity.vue
index c0a9751..c96a179 100644
--- a/packages/frontend/src/components/dashboard/RecentActivity.vue
+++ b/packages/frontend/src/components/dashboard/RecentActivity.vue
@@ -1,17 +1,7 @@
 <script setup lang="ts">
 import Button from "primevue/button";
 import Card from "primevue/card";
-
-type DashboardActivity = {
-  id: string;
-  title: string;
-  url: string;
-  description?: string;
-  createdAt: Date;
-  status: string;
-  type: string;
-  attackSessionId?: string;
-};
+import type { DashboardActivity } from "shared";
 
 defineProps<{
   recentSessions: DashboardActivity[];
diff --git a/packages/frontend/src/components/dashboard/useScanning.ts b/packages/frontend/src/components/dashboard/useScanning.ts
index 3522ee6..c1010e0 100644
--- a/packages/frontend/src/components/dashboard/useScanning.ts
+++ b/packages/frontend/src/components/dashboard/useScanning.ts
@@ -1,4 +1,4 @@
-import type { Result } from "shared";
+import type { DashboardActivity, Result } from "shared";
 import { computed, onMounted, onUnmounted, ref } from "vue";
 
 import { useSDK } from "@/plugins/sdk";
@@ -12,16 +12,6 @@ export function useScanning(
 
   const scanUrl = ref("");
   const isScanning = ref(false);
-  type DashboardActivity = {
-    id: string;
-    title: string;
-    url: string;
-    description?: string;
-    createdAt: Date;
-    status: string;
-    type: string;
-    attackSessionId?: string;
-  };
 
   const recentSessions = ref<DashboardActivity[]>([]);
   const customHeaders = ref<Array<{ name: string; value: string }>>([]);
diff --git a/packages/frontend/src/components/dashboard/useSchemaImport.ts b/packages/frontend/src/components/dashboard/useSchemaImport.ts
new file mode 100644
index 0000000..07f141e
--- /dev/null
+++ b/packages/frontend/src/components/dashboard/useSchemaImport.ts
@@ -0,0 +1,122 @@
+import type {
+  DashboardActivity,
+  ExplorerSession,
+  Result,
+  SchemaImportResult,
+} from "shared";
+
+import { useSDK } from "@/plugins/sdk";
+
+function generateId(): string {
+  return Date.now().toString(36) + Math.random().toString(36).substring(2);
+}
+
+type StorageData = {
+  explorerSessions?: ExplorerSession[];
+  selectedExplorerSessionId?: string;
+  dashboardActivities?: DashboardActivity[];
+};
+
+export function useSchemaImport(
+  navigateTo?: (
+    page: "Dashboard" | "Explorer" | "Voyager" | "Attacks" | "History",
+  ) => void,
+  onSessionsChanged?: () => void,
+) {
+  const sdk = useSDK();
+
+  const importSchemaFile = async (
+    fileContent: string,
+    fileName: string,
+  ): Promise<boolean> => {
+    try {
+      const result: Result<SchemaImportResult & { fileName: string }> =
+        await sdk.backend.importSchemaFromFile(fileContent, fileName);
+
+      if (result.kind === "Error") {
+        sdk.window.showToast(`Import failed: ${result.error}`, {
+          variant: "error",
+        });
+        return false;
+      }
+
+      const currentStorage: StorageData =
+        (sdk.storage.get() as StorageData | undefined) ?? {};
+
+      if (
+        currentStorage.explorerSessions === undefined ||
+        !Array.isArray(currentStorage.explorerSessions)
+      ) {
+        currentStorage.explorerSessions = [];
+      }
+
+      if (
+        currentStorage.dashboardActivities === undefined ||
+        !Array.isArray(currentStorage.dashboardActivities)
+      ) {
+        currentStorage.dashboardActivities = [];
+      }
+
+      const displayName = fileName.replace(/\.(json|graphql|gql)$/i, "");
+
+      const sessionData: ExplorerSession = {
+        id: generateId(),
+        title: displayName,
+        url: `file://${fileName}`,
+        schema: result.value.schema,
+        supportsIntrospection: true,
+        createdAt: new Date(),
+        status: "success",
+        sourceType: "file-import",
+      };
+
+      currentStorage.explorerSessions.push(sessionData);
+      currentStorage.selectedExplorerSessionId = sessionData.id;
+
+      const activityData: DashboardActivity = {
+        id: generateId(),
+        title: `Schema import: ${displayName}`,
+        url: `file://${fileName}`,
+        description: `Imported from ${fileName} (${result.value.format})`,
+        createdAt: new Date(),
+        status: "success",
+        type: "scan",
+      };
+
+      currentStorage.dashboardActivities.unshift(activityData);
+
+      if (currentStorage.dashboardActivities.length > 20) {
+        currentStorage.dashboardActivities =
+          currentStorage.dashboardActivities.slice(0, 20);
+      }
+
+      await sdk.storage.set(currentStorage as unknown as Record<string, never>);
+
+      onSessionsChanged?.();
+
+      window.dispatchEvent(
+        new CustomEvent("graphql-analyzer-sessions-updated"),
+      );
+
+      sdk.window.showToast(`Schema imported successfully from "${fileName}"!`, {
+        variant: "success",
+      });
+
+      setTimeout(() => {
+        if (navigateTo !== undefined) {
+          navigateTo("Explorer");
+        }
+      }, 800);
+
+      return true;
+    } catch (err) {
+      const errorMsg = err instanceof Error ? err.message : "Unknown error";
+      sdk.window.showToast(`Import failed: ${errorMsg}`, { variant: "error" });
+      return false;
+    }
+  };
+
+  return {
+    importSchemaFile,
+  };
+}
diff --git a/packages/frontend/src/index.ts b/packages/frontend/src/index.ts
index 49426a1..753c2d3 100644
--- a/packages/frontend/src/index.ts
+++ b/packages/frontend/src/index.ts
@@ -39,43 +39,69 @@ export const init = (sdk: FrontendSDK) => {
     icon: "fas fa-project-diagram",
   });
 
-  sdk.httpHistory.addRequestViewMode({
-    label: "GraphQL",
-    view: {
-      component: GraphQLViewMode,
-    },
-  });
-
-  try {
-    type ReplaySDK = {
-      addRequestViewMode?: (config: {
-        label: string;
-        view: { component: unknown };
-      }) => void;
-    };
-    const replaySDK = sdk.replay as ReplaySDK;
-    replaySDK.addRequestViewMode?.({
-      label: "GraphQL",
-      view: {
-        component: GraphQLViewMode,
-      },
-    });
-  } catch {
-    // Ignore replay SDK errors if not available
+  // Detect whether a raw HTTP request contains a GraphQL query
+  function isGraphQLRequest(raw: string): boolean {
+    if (raw === "" || raw.trim() === "") return false;
+
+    // Split headers from body
+    let parts = raw.split("\r\n\r\n");
+    if (parts.length < 2) {
+      parts = raw.split("\n\n");
+      if (parts.length < 2) return false;
+    }
+
+    const headerSection = parts[0] ?? "";
+    const firstLine = headerSection.split(/\r?\n/)[0] ?? "";
+
+    // Must be a POST request
+    if (!firstLine.startsWith("POST ")) return false;
+
+    const separator = raw.includes("\r\n") ? "\r\n\r\n" : "\n\n";
+    const body = parts.slice(1).join(separator).trim();
+    if (!body) return false;
+
+    try {
+      const parsed = JSON.parse(body) as { query?: unknown };
+      return typeof parsed.query === "string" && parsed.query.trim() !== "";
+    } catch {
+      return false;
+    }
   }
-  sdk.search.addRequestViewMode({
-    label: "GraphQL",
-    view: {
-      component: GraphQLViewMode,
-    },
-  });
 
-  sdk.sitemap.addRequestViewMode({
+  type ViewModeOptions = {
+    label: string;
+    view: { component: unknown };
+    when?: (...args: unknown[]) => boolean;
+  };
+
+  type ExtendedViewModeSDK = {
+    addRequestViewMode: (options: ViewModeOptions) => void;
+  };
+
+  const requestViewMode: ViewModeOptions = {
     label: "GraphQL",
-    view: {
-      component: GraphQLViewMode,
+    view: { component: GraphQLViewMode },
+    when: (request: unknown) => {
+      const req = request as { raw?: string } | undefined;
+      return isGraphQLRequest(req?.raw ?? "");
     },
-  });
+  };
+
+  const surfaces = [
+    sdk.httpHistory,
+    sdk.replay,
+    sdk.search,
+    sdk.sitemap,
+    sdk.intercept,
+  ] as unknown as ExtendedViewModeSDK[];
+
+  for (const surface of surfaces) {
+    try {
+      surface.addRequestViewMode(requestViewMode);
+    } catch {
+      // ignore
+    }
+  }
 
   sdk.commands.register("graphql-analyzer-scan", {
     name: "Scan GraphQL Endpoint",
diff --git a/packages/frontend/src/views/GraphQLViewMode.vue b/packages/frontend/src/views/GraphQLViewMode.vue
index 0748e25..67f21a4 100644
--- a/packages/frontend/src/views/GraphQLViewMode.vue
+++ b/packages/frontend/src/views/GraphQLViewMode.vue
@@ -24,6 +24,12 @@ const editableVariables = ref("{}");
 const editableOperationName = ref("");
 const queryValidationErrors = ref<string[]>([]);
 const activeTab = ref(0);
+type MinimalEditorView = {
+  state: { doc: { toString(): string; length: number } };
+  dispatch(tr: { changes: { from: number; to: number; insert: string } }): void;
+};
+
+const cachedEditorView = ref<MinimalEditorView | undefined>(undefined);
 
 const originalQuery = ref("");
 const originalVariables = ref("{}");
@@ -32,12 +38,12 @@ const originalOperationName = ref("");
 const isReplayTab = computed(() => window.location.hash.includes("/replay"));
 
 const parseHttpRaw = (raw: string) => {
-  if (raw === undefined || raw === "") return null;
+  if (raw === undefined || raw === "") return undefined;
 
   let parts = raw.split("\r\n\r\n");
   if (parts.length < 2) {
     parts = raw.split("\n\n");
-    if (parts.length < 2) return null;
+    if (parts.length < 2) return undefined;
   }
 
   const headerSection = parts[0];
@@ -92,9 +98,21 @@ const getRawData = computed((): string => {
   return "";
 });
 
+const tryGetEditorView = () => {
+  const editor = props.sdk.window?.getActiveEditor?.();
+  if (editor !== undefined && editor !== null) {
+    const editorView = editor.getEditorView();
+    if (editorView !== undefined && editorView !== null) {
+      cachedEditorView.value = editorView;
+      return editorView;
+    }
+  }
+  return cachedEditorView.value;
+};
+
 const parsedHttp = computed(() => {
   const raw = getRawData.value;
-  if (!raw || raw.trim() === "") return null;
+  if (raw === "" || raw.trim() === "") return undefined;
   const parsed = parseHttpRaw(raw);
   return parsed;
 });
@@ -142,12 +160,12 @@ const isGraphQLQuery = (text: string): boolean => {
 
 const graphqlData = computed(() => {
   const parsed = parsedHttp.value;
-  if (parsed === null || parsed.body === undefined || parsed.body === "") {
-    return null;
+  if (parsed === undefined || parsed.body === undefined || parsed.body === "") {
+    return undefined;
   }
 
   const body = parsed.body.trim();
-  if (!body) return null;
+  if (body === "") return undefined;
 
   try {
     const bodyJson = JSON.parse(body) as {
@@ -172,15 +190,15 @@ const graphqlData = computed(() => {
     }
   }
 
-  return null;
+  return undefined;
 });
 
 const isActuallyGraphQL = computed(() => {
   if (props.request === undefined || props.request === null) return false;
   const parsed = parsedHttp.value;
-  if (parsed === null || parsed === undefined) return false;
+  if (parsed === undefined) return false;
 
-  return parsed.method === "POST" && graphqlData.value !== null;
+  return parsed.method === "POST" && graphqlData.value !== undefined;
 });
 
 const formatGraphQLQuery = (query: string): string => {
@@ -258,6 +276,7 @@ const initializeData = () => {
 
 onMounted(async () => {
   await nextTick();
+  tryGetEditorView();
   initializeData();
 });
 
@@ -557,7 +576,6 @@ const reconstructGraphQLBody = (): string => {
 const reconstructRawHttpRequest = (newBody: string): string => {
   const parsed = parsedHttp.value;
   if (
-    parsed === null ||
     parsed === undefined ||
     props.request === undefined ||
     props.request === null
@@ -615,30 +633,29 @@ const saveChanges = () => {
     const newBody = reconstructGraphQLBody();
     const newRaw = reconstructRawHttpRequest(newBody);
 
-    const editor = props.sdk.window?.getActiveEditor?.();
-    if (editor !== undefined && editor !== null) {
-      const editorView = editor.getEditorView();
-      if (editorView !== undefined && editorView !== null) {
-        editorView.dispatch({
-          changes: {
-            from: 0,
-            to: editorView.state.doc.length,
-            insert: newRaw,
-          },
-        });
-
-        originalQuery.value = editableQuery.value;
-        originalVariables.value = editableVariables.value;
-        originalOperationName.value = editableOperationName.value;
-
-        props.sdk.window.showToast("Request updated successfully", {
-          variant: "success",
-        });
-      } else {
-        throw new Error("Editor view not available");
-      }
+    const editorView = tryGetEditorView();
+
+    if (editorView !== undefined && editorView !== null) {
+      editorView.dispatch({
+        changes: {
+          from: 0,
+          to: editorView.state.doc.length,
+          insert: newRaw,
+        },
+      });
+
+      originalQuery.value = editableQuery.value;
+      originalVariables.value = editableVariables.value;
+      originalOperationName.value = editableOperationName.value;
+
+      props.sdk.window.showToast("Request updated successfully", {
+        variant: "success",
+      });
     } else {
-      throw new Error("Active editor not available");
+      props.sdk.window.showToast(
+        "Switch to the Raw tab first, then back to GraphQL to enable editing.",
+        { variant: "warning" },
+      );
     }
   } catch (error) {
     const errorMessage =
@@ -653,7 +670,6 @@ const saveChanges = () => {
 <template>
   <div class="h-full flex flex-col bg-surface-800">
     <div v-if="isActuallyGraphQL" class="flex-1 min-h-0 flex flex-col">
-      <!-- Clean Action Toolbar -->
       <div
         class="flex items-center justify-between p-2 border-b border-surface-600 flex-shrink-0"
       >
@@ -703,7 +719,6 @@ const saveChanges = () => {
         </div>
       </div>
 
-      <!-- Full Width Content -->
       <div class="flex-1 min-h-0 overflow-hidden">
         <TabView
           v-model="activeTab"
@@ -714,10 +729,8 @@ const saveChanges = () => {
             panelContainer: { class: 'flex-1 min-h-0 overflow-hidden' },
           }"
         >
-          <!-- Query Tab -->
           <TabPanel header="Query" :pt="{ content: { class: 'h-full p-0' } }">
             <div class="h-full flex flex-col p-2">
-              <!-- Operation Name (editable in Replay) -->
               <div
                 v-if="isReplayTab || graphqlData?.operationName"
                 class="mb-2 flex-shrink-0"
@@ -736,7 +749,6 @@ const saveChanges = () => {
                 </div>
               </div>
 
-              <!-- Validation Errors -->
               <div
                 v-if="queryValidationErrors.length > 0"
                 class="border border-red-500 rounded p-2 mb-2 flex-shrink-0"
@@ -759,7 +771,6 @@ const saveChanges = () => {
                 </ul>
               </div>
 
-              <!-- Enhanced Query Display -->
               <div
                 class="flex-1 min-h-0 border border-surface-600 rounded overflow-hidden bg-surface-900"
               >
@@ -775,13 +786,11 @@ const saveChanges = () => {
             </div>
           </TabPanel>
 
-          <!-- Variables Tab -->
           <TabPanel
             header="Variables"
             :pt="{ content: { class: 'h-full p-0' } }"
           >
             <div class="h-full flex gap-2 p-2">
-              <!-- Variables JSON -->
               <div class="flex-1 min-w-0 flex flex-col">
                 <div class="mb-2 flex-shrink-0">
                   <h4 class="text-sm font-medium text-surface-200">
@@ -805,7 +814,6 @@ const saveChanges = () => {
                 </div>
               </div>
 
-              <!-- Query Fields Info -->
               <div class="w-80 flex-shrink-0 flex flex-col">
                 <div class="mb-2 flex-shrink-0">
                   <h4 class="text-sm font-medium text-surface-200">
@@ -853,14 +861,12 @@ const saveChanges = () => {
             </div>
           </TabPanel>
 
-          <!-- Request Info Tab -->
           <TabPanel
             header="Request Info"
             :pt="{ content: { class: 'h-full p-0' } }"
           >
             <div class="h-full overflow-auto p-2">
               <div class="space-y-3">
-                <!-- Operation Info -->
                 <div
                   v-if="graphqlData?.operationName"
                   class="border border-surface-600 rounded p-3"
@@ -876,7 +882,6 @@ const saveChanges = () => {
                   </div>
                 </div>
 
-                <!-- Endpoint Details -->
                 <div class="border border-surface-600 rounded p-3">
                   <h4
                     class="text-sm font-medium text-surface-200 mb-2 flex items-center gap-2"
@@ -914,7 +919,6 @@ const saveChanges = () => {
                   </div>
                 </div>
 
-                <!-- Security Headers -->
                 <div class="border border-surface-600 rounded p-3">
                   <h4
                     class="text-sm font-medium text-surface-200 mb-2 flex items-center gap-2"
@@ -963,7 +967,6 @@ const saveChanges = () => {
         </TabView>
       </div>
 
-      <!-- Minimal Status Bar -->
       <div
         class="flex items-center justify-between px-3 py-1 border-t border-surface-600 bg-surface-800 text-xs flex-shrink-0"
       >
@@ -981,7 +984,6 @@ const saveChanges = () => {
       </div>
     </div>
 
-    <!-- Not GraphQL State -->
     <div v-else class="flex-1 flex items-center justify-center">
       <div class="text-center text-surface-500">
         <i class="fas fa-exclamation-circle text-4xl mb-4"></i>
diff --git a/packages/shared/src/index.ts b/packages/shared/src/index.ts
index e3c4b4e..331b366 100644
--- a/packages/shared/src/index.ts
+++ b/packages/shared/src/index.ts
@@ -186,3 +186,31 @@ export type AttackSession = {
   totalFindings: number;
   criticalFindings: number;
 };
+
+export type DashboardActivity = {
+  id: string;
+  title: string;
+  url: string;
+  description?: string;
+  createdAt: Date;
+  status: string;
+  type: string;
+  attackSessionId?: string;
+};
+
+export type ExplorerSession = {
+  id: string;
+  title: string;
+  url: string;
+  schema?: GraphQLSchema;
+  supportsIntrospection: boolean;
+  createdAt: Date;
+  status: string;
+  requestId?: string;
+  sourceType?: string;
+};
+
+export type SchemaImportResult = {
+  schema: GraphQLSchema;
+  format: string;
+};
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index 760685a..d7a314e 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -48,6 +48,9 @@ importers:
       typescript:
         specifier: 5.5.4
         version: 5.5.4
+      vitest:
+        specifier: 4.0.18
+        version: 4.0.18(@types/node@25.0.3)(jiti@2.4.2)(yaml@2.8.1)
 
   packages/backend:
     dependencies:
@@ -542,41 +545,49 @@ packages:
     resolution: {integrity: sha512-xlMh4gNtplNQEwuF5icm69udC7un0WyzT5ywOeHrPMEsghKnLjXok2wZgAA7ocTm9+JsI+nVXIQa5XO1x+HPQg==}
     cpu: [arm64]
     os: [linux]
+    libc: [glibc]
 
   '@oxc-resolver/binding-linux-arm64-musl@11.16.2':
     resolution: {integrity: sha512-OZs33QTMi0xmHv/4P0+RAKXJTBk7UcMH5tpTaCytWRXls/DGaJ48jOHmriQGK2YwUqXl+oneuNyPOUO0obJ+Hg==}
     cpu: [arm64]
     os: [linux]
+    libc: [musl]
 
   '@oxc-resolver/binding-linux-ppc64-gnu@11.16.2':
     resolution: {integrity: sha512-UVyuhaV32dJGtF6fDofOcBstg9JwB2Jfnjfb8jGlu3xcG+TsubHRhuTwQ6JZ1sColNT1nMxBiu7zdKUEZi1kwg==}
     cpu: [ppc64]
     os: [linux]
+    libc: [glibc]
 
   '@oxc-resolver/binding-linux-riscv64-gnu@11.16.2':
     resolution: {integrity: sha512-YZZS0yv2q5nE1uL/Fk4Y7m9018DSEmDNSG8oJzy1TJjA1jx5HL52hEPxi98XhU6OYhSO/vC1jdkJeE8TIHugug==}
     cpu: [riscv64]
     os: [linux]
+    libc: [glibc]
 
   '@oxc-resolver/binding-linux-riscv64-musl@11.16.2':
     resolution: {integrity: sha512-9VYuypwtx4kt1lUcwJAH4dPmgJySh4/KxtAPdRoX2BTaZxVm/yEXHq0mnl/8SEarjzMvXKbf7Cm6UBgptm3DZw==}
     cpu: [riscv64]
     os: [linux]
+    libc: [musl]
 
   '@oxc-resolver/binding-linux-s390x-gnu@11.16.2':
     resolution: {integrity: sha512-3gbwQ+xlL5gpyzgSDdC8B4qIM4mZaPDLaFOi3c/GV7CqIdVJc5EZXW4V3T6xwtPBOpXPXfqQLbhTnUD4SqwJtA==}
     cpu: [s390x]
     os: [linux]
+    libc: [glibc]
 
   '@oxc-resolver/binding-linux-x64-gnu@11.16.2':
     resolution: {integrity: sha512-m0WcK0j54tSwWa+hQaJMScZdWneqE7xixp/vpFqlkbhuKW9dRHykPAFvSYg1YJ3MJgu9ZzVNpYHhPKJiEQq57Q==}
     cpu: [x64]
     os: [linux]
+    libc: [glibc]
 
   '@oxc-resolver/binding-linux-x64-musl@11.16.2':
     resolution: {integrity: sha512-ZjUm3w96P2t47nWywGwj1A2mAVBI/8IoS7XHhcogWCfXnEI3M6NPIRQPYAZW4s5/u3u6w1uPtgOwffj2XIOb/g==}
     cpu: [x64]
     os: [linux]
+    libc: [musl]
 
   '@oxc-resolver/binding-openharmony-arm64@11.16.2':
     resolution: {integrity: sha512-OFVQ2x3VenTp13nIl6HcQ/7dmhFmM9dg2EjKfHcOtYfrVLQdNR6THFU7GkMdmc8DdY1zLUeilHwBIsyxv5hkwQ==}
@@ -663,56 +674,67 @@ packages:
     resolution: {integrity: sha512-u72Mzc6jyJwKjJbZZcIYmd9bumJu7KNmHYdue43vT1rXPm2rITwmPWF0mmPzLm9/vJWxIRbao/jrQmxTO0Sm9w==}
     cpu: [arm]
     os: [linux]
+    libc: [glibc]
 
   '@rollup/rollup-linux-arm-musleabihf@4.50.0':
     resolution: {integrity: sha512-S4UefYdV0tnynDJV1mdkNawp0E5Qm2MtSs330IyHgaccOFrwqsvgigUD29uT+B/70PDY1eQ3t40+xf6wIvXJyg==}
     cpu: [arm]
     os: [linux]
+    libc: [musl]
 
   '@rollup/rollup-linux-arm64-gnu@4.50.0':
     resolution: {integrity: sha512-1EhkSvUQXJsIhk4msxP5nNAUWoB4MFDHhtc4gAYvnqoHlaL9V3F37pNHabndawsfy/Tp7BPiy/aSa6XBYbaD1g==}
     cpu: [arm64]
     os: [linux]
+    libc: [glibc]
 
   '@rollup/rollup-linux-arm64-musl@4.50.0':
     resolution: {integrity: sha512-EtBDIZuDtVg75xIPIK1l5vCXNNCIRM0OBPUG+tbApDuJAy9mKago6QxX+tfMzbCI6tXEhMuZuN1+CU8iDW+0UQ==}
     cpu: [arm64]
     os: [linux]
+    libc: [musl]
 
   '@rollup/rollup-linux-loongarch64-gnu@4.50.0':
     resolution: {integrity: sha512-BGYSwJdMP0hT5CCmljuSNx7+k+0upweM2M4YGfFBjnFSZMHOLYR0gEEj/dxyYJ6Zc6AiSeaBY8dWOa11GF/ppQ==}
     cpu: [loong64]
     os: [linux]
+    libc: [glibc]
 
   '@rollup/rollup-linux-ppc64-gnu@4.50.0':
     resolution: {integrity: sha512-I1gSMzkVe1KzAxKAroCJL30hA4DqSi+wGc5gviD0y3IL/VkvcnAqwBf4RHXHyvH66YVHxpKO8ojrgc4SrWAnLg==}
     cpu: [ppc64]
     os: [linux]
+    libc: [glibc]
 
   '@rollup/rollup-linux-riscv64-gnu@4.50.0':
     resolution: {integrity: sha512-bSbWlY3jZo7molh4tc5dKfeSxkqnf48UsLqYbUhnkdnfgZjgufLS/NTA8PcP/dnvct5CCdNkABJ56CbclMRYCA==}
     cpu: [riscv64]
     os: [linux]
+    libc: [glibc]
 
   '@rollup/rollup-linux-riscv64-musl@4.50.0':
     resolution: {integrity: sha512-LSXSGumSURzEQLT2e4sFqFOv3LWZsEF8FK7AAv9zHZNDdMnUPYH3t8ZlaeYYZyTXnsob3htwTKeWtBIkPV27iQ==}
     cpu: [riscv64]
     os: [linux]
+    libc: [musl]
 
   '@rollup/rollup-linux-s390x-gnu@4.50.0':
     resolution: {integrity: sha512-CxRKyakfDrsLXiCyucVfVWVoaPA4oFSpPpDwlMcDFQvrv3XY6KEzMtMZrA+e/goC8xxp2WSOxHQubP8fPmmjOQ==}
     cpu: [s390x]
     os: [linux]
+    libc: [glibc]
 
   '@rollup/rollup-linux-x64-gnu@4.50.0':
     resolution: {integrity: sha512-8PrJJA7/VU8ToHVEPu14FzuSAqVKyo5gg/J8xUerMbyNkWkO9j2ExBho/68RnJsMGNJq4zH114iAttgm7BZVkA==}
     cpu: [x64]
     os: [linux]
+    libc: [glibc]
 
   '@rollup/rollup-linux-x64-musl@4.50.0':
     resolution: {integrity: sha512-SkE6YQp+CzpyOrbw7Oc4MgXFvTw2UIBElvAvLCo230pyxOLmYwRPwZ/L5lBe/VW/qT1ZgND9wJfOsdy0XptRvw==}
     cpu: [x64]
     os: [linux]
+    libc: [musl]
 
   '@rollup/rollup-openharmony-arm64@4.50.0':
     resolution: {integrity: sha512-PZkNLPfvXeIOgJWA804zjSFH7fARBBCpCXxgkGDRjjAhRLOR8o0IGS01ykh5GYfod4c2yiiREuDM8iZ+pVsT+Q==}
@@ -737,6 +759,9 @@ packages:
   '@rtsao/scc@1.1.0':
     resolution: {integrity: sha512-zt6OdqaDoOnJ1ZYsCYGt9YmWzDXl4vQdKTyJev62gFhRGKdx7mcT54V9KIjg+d2wi9EXsPvAPKe7i7WjfVWB8g==}
 
+  '@standard-schema/spec@1.1.0':
+    resolution: {integrity: sha512-l2aFy5jALhniG5HgqrD6jXLi/rUWrKvqN/qJx6yoJsgKhblVd+iqqU4RCXavm/jPityDo5TCvKMnpjKnOriy0w==}
+
   '@tanstack/virtual-core@3.13.18':
     resolution: {integrity: sha512-Mx86Hqu1k39icq2Zusq+Ey2J6dDWTjDvEv43PJtRCoEYTLyfaPnxIQ6iy7YAOK0NV/qOEmZQ/uCufrppZxTgcg==}
 
@@ -748,6 +773,9 @@ packages:
   '@tybys/wasm-util@0.10.1':
     resolution: {integrity: sha512-9tTaPJLSiejZKx+Bmog4uSubteqTvFrVrURwkmHixBo0G4seD0zUxp98E1DzUBJxLQ3NPwXrGKDiVjwx/DpPsg==}
 
+  '@types/chai@5.2.3':
+    resolution: {integrity: sha512-Mw558oeA9fFbv65/y4mHtXDs9bPnFMZAL/jxdPFUpOHHIXX91mcgEHbS5Lahr+pwZFR8A7GQleRWeI6cGFC2UA==}
+
   '@types/d3-array@3.2.1':
     resolution: {integrity: sha512-Y2Jn2idRrLzUfAKV2LyRImR+y4oa2AntrgID95SHJxuMUrkNXmanDSed71sRNZysveJVt1hLLemQZIady0FpEg==}
 
@@ -841,6 +869,9 @@ packages:
   '@types/d3@7.4.3':
     resolution: {integrity: sha512-lZXZ9ckh5R8uiFVt8ogUNf+pIrK4EsWrx2Np75WvF/eTpJ0FMHNhjXk8CKEx/+gpHbNQyJWehbFaTvqmHWB3ww==}
 
+  '@types/deep-eql@4.0.2':
+    resolution: {integrity: sha512-c9h9dVVMigMPc4bwTvC5dxqtqJZwQPePsWjPlpSOnojbor6pGqdk541lfA7AqFQr5pB1BRdq0juY9db81BwyFw==}
+
   '@types/estree@1.0.8':
     resolution: {integrity: sha512-dWHzHa2WqEXI/O1E9OjrocMTKJl2mSrEolh1Iomrv6U+JuNwaHXsXx9bLu5gG7BUWFIN0skIQJQ/L1rIex4X6w==}
 
@@ -913,6 +944,35 @@ packages:
       vite: ^5.0.0 || ^6.0.0
       vue: ^3.2.25
 
+  '@vitest/expect@4.0.18':
+    resolution: {integrity: sha512-8sCWUyckXXYvx4opfzVY03EOiYVxyNrHS5QxX3DAIi5dpJAAkyJezHCP77VMX4HKA2LDT/Jpfo8i2r5BE3GnQQ==}
+
+  '@vitest/mocker@4.0.18':
+    resolution: {integrity: sha512-HhVd0MDnzzsgevnOWCBj5Otnzobjy5wLBe4EdeeFGv8luMsGcYqDuFRMcttKWZA5vVO8RFjexVovXvAM4JoJDQ==}
+    peerDependencies:
+      msw: ^2.4.9
+      vite: ^6.0.0 || ^7.0.0-0
+    peerDependenciesMeta:
+      msw:
+        optional: true
+      vite:
+        optional: true
+
+  '@vitest/pretty-format@4.0.18':
+    resolution: {integrity: sha512-P24GK3GulZWC5tz87ux0m8OADrQIUVDPIjjj65vBXYG17ZeU3qD7r+MNZ1RNv4l8CGU2vtTRqixrOi9fYk/yKw==}
+
+  '@vitest/runner@4.0.18':
+    resolution: {integrity: sha512-rpk9y12PGa22Jg6g5M3UVVnTS7+zycIGk9ZNGN+m6tZHKQb7jrP7/77WfZy13Y/EUDd52NDsLRQhYKtv7XfPQw==}
+
+  '@vitest/snapshot@4.0.18':
+    resolution: {integrity: sha512-PCiV0rcl7jKQjbgYqjtakly6T1uwv/5BQ9SwBLekVg/EaYeQFPiXcgrC2Y7vDMA8dM1SUEAEV82kgSQIlXNMvA==}
+
+  '@vitest/spy@4.0.18':
+    resolution: {integrity: sha512-cbQt3PTSD7P2OARdVW3qWER5EGq7PHlvE+QfzSC0lbwO+xnt7+XH06ZzFjFRgzUX//JmpxrCu92VdwvEPlWSNw==}
+
+  '@vitest/utils@4.0.18':
+    resolution: {integrity: sha512-msMRKLMVLWygpK3u2Hybgi4MNjcYJvwTb0Ru09+fOyCXIgT5raYP041DRRdiJiI3k/2U6SEbAETB3YtBrUkCFA==}
+
   '@volar/language-core@2.4.23':
     resolution: {integrity: sha512-hEEd5ET/oSmBC6pi1j6NaNYRWoAiDhINbT8rmwtINugR39loROSlufGdYMF9TaKGfz+ViGs1Idi3mAhnuPcoGQ==}
 
@@ -1053,6 +1113,10 @@ packages:
     resolution: {integrity: sha512-BNoCY6SXXPQ7gF2opIP4GBE+Xw7U+pHMYKuzjgCN3GwiaIR09UUeKfheyIry77QtrCBlC0KK0q5/TER/tYh3PQ==}
     engines: {node: '>= 0.4'}
 
+  assertion-error@2.0.1:
+    resolution: {integrity: sha512-Izi8RQcffqCeNVgFigKli1ssklIbpHnCYc6AknXGYoB6grJqyeby7jv12JUQgmTAnIDnbck1uxksT4dzN3PWBA==}
+    engines: {node: '>=12'}
+
   ast-metadata-inferer@0.8.1:
     resolution: {integrity: sha512-ht3Dm6Zr7SXv6t1Ra6gFo0+kLDglHGrEbYihTkcycrbHw7WCcuhBzPlJYHEsIpycaUwzsJHje+vUcxXUX4ztTA==}
 
@@ -1130,6 +1194,10 @@ packages:
   caniuse-lite@1.0.30001739:
     resolution: {integrity: sha512-y+j60d6ulelrNSwpPyrHdl+9mJnQzHBr08xm48Qno0nSk4h3Qojh+ziv2qE6rXf4k3tadF4o1J/1tAbVm1NtnA==}
 
+  chai@6.2.2:
+    resolution: {integrity: sha512-NUPRluOfOiTKBKvWPtSD4PhFvWCqOi0BGStNWs57X9js7XGTprSmFoz5F0tWhR4WPjNeR9jXqdC7/UpSJTnlRg==}
+    engines: {node: '>=18'}
+
   chalk@4.1.2:
     resolution: {integrity: sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==}
     engines: {node: '>=10'}
@@ -1455,6 +1523,9 @@ packages:
     resolution: {integrity: sha512-Zf5H2Kxt2xjTvbJvP2ZWLEICxA6j+hAmMzIlypy4xcBg1vKVnx89Wy0GbS+kf5cwCVFFzdCFh2XSCFNULS6csw==}
     engines: {node: '>= 0.4'}
 
+  es-module-lexer@1.7.0:
+    resolution: {integrity: sha512-jEQoCwk8hyb2AZziIOLhDqpm5+2ww5uIE6lkO/6jcOCusfk6LhMHpXXfBLXTZ7Ydyt0j4VoUQv6uGNYbdW+kBA==}
+
   es-object-atoms@1.1.1:
     resolution: {integrity: sha512-FGgH2h8zKNim9ljj7dankFPcICIK9Cp5bm+c2gQSYePhpaG5+esrLODihIorn+Pe6FGJzWhXQotPv73jTaldXA==}
     engines: {node: '>= 0.4'}
@@ -1620,6 +1691,9 @@ packages:
   estree-walker@2.0.2:
     resolution: {integrity: sha512-Rfkk/Mp/DL7JVje3u18FxFujQlTNR2q6QfMSMB7AvCBx91NGj/ba3kCfza0f6dVDbw7YlRf/nDrn7pQrCCyQ/w==}
 
+  estree-walker@3.0.3:
+    resolution: {integrity: sha512-7RUKfXgSMMkzt6ZuXmqapOurLGPPfgj6l9uRZ7lRGolvk0y2yocc35LdcxKC5PQZdn2DMqioAQ2NoWcrTKmm6g==}
+
   esutils@2.0.3:
     resolution: {integrity: sha512-kVscqXk4OCp68SZ0dkgEKVi6/8ij300KBWTJq32P/dYeWTSwK41WyTxalN1eRmA5Z9UU/LX9D7FWSmV9SAYx6g==}
     engines: {node: '>=0.10.0'}
@@ -1628,6 +1702,10 @@ packages:
     resolution: {integrity: sha512-aIL5Fx7mawVa300al2BnEE4iNvo1qETxLrPI/o05L7z6go7fCw1J6EQmbK4FmJ2AS7kgVF/KEZWufBfdClMcPg==}
     engines: {node: '>= 0.6'}
 
+  expect-type@1.3.0:
+    resolution: {integrity: sha512-knvyeauYhqjOYvQ66MznSMs83wmHrCycNEN6Ao+2AeYEfxUIkuiVxdEa1qlGEPK+We3n0THiDciYSsCcgW/DoA==}
+    engines: {node: '>=12.0.0'}
+
   express@5.0.0:
     resolution: {integrity: sha512-V4UkHQc+B7ldh1YC84HCXHwf60M4BOMvp9rkvTUWCK5apqDC1Esnbid4wm6nFyVuDy8XMfETsJw5lsIGBWyo0A==}
     engines: {node: '>= 18'}
@@ -2085,6 +2163,9 @@ packages:
   magic-string@0.30.18:
     resolution: {integrity: sha512-yi8swmWbO17qHhwIBNeeZxTceJMeBvWJaId6dyvTSOwTipqeHhMhOrz6513r1sOKnpvQ7zkhlG8tPrpilwTxHQ==}
 
+  magic-string@0.30.21:
+    resolution: {integrity: sha512-vd2F4YUyEXKGcLHoq+TEyCjxueSeHnFxyyjNp80yg0XV4vUhnDer/lvvlqM/arB5bXQN5K2/3oinyCRyx8T2CQ==}
+
   math-intrinsics@1.1.0:
     resolution: {integrity: sha512-/IXtbwEk5HTPyEwyKX6hGkYXxM9nbj64B+ilVJnC/R6B0pH5G4V3b0pVbL7DBj4tkhBAppbQUlf6F6Xl9LHu1g==}
     engines: {node: '>= 0.4'}
@@ -2201,6 +2282,9 @@ packages:
     resolution: {integrity: sha512-gXah6aZrcUxjWg2zR2MwouP2eHlCBzdV4pygudehaKXSGW4v2AsRQUK+lwwXhii6KFZcunEnmSUoYp5CXibxtA==}
     engines: {node: '>= 0.4'}
 
+  obug@2.1.1:
+    resolution: {integrity: sha512-uTqF9MuPraAQ+IsnPf366RG4cP9RtUi7MLO1N3KEc+wb0a6yKpeL0lmk2IB1jY5KHPAlTc6T/JRdC/YqxHNwkQ==}
+
   on-finished@2.4.1:
     resolution: {integrity: sha512-oVlzkg3ENAhCk2zdv7IJwd/QUD4z2RxRwpkcGY8psCVcCYZNq4wYnVWALHM+brtuJjePWiYF/ClmuDr8Ch5+kg==}
     engines: {node: '>= 0.8'}
@@ -2267,6 +2351,9 @@ packages:
     resolution: {integrity: sha512-TdrF7fW9Rphjq4RjrW0Kp2AW0Ahwu9sRGTkS6bvDi0SCwZlEZYmcfDbEsTz8RVk0EHIS/Vd1bv3JhG+1xZuAyQ==}
     engines: {node: '>=16'}
 
+  pathe@2.0.3:
+    resolution: {integrity: sha512-WUjGcAqP1gQacoQe+OBJsFA7Ld4DyXuUIjZ5cc75cLHvJ7dtNsTugphxIADwspS+AraAUePCKrSVtPLFj/F88w==}
+
   picocolors@1.1.1:
     resolution: {integrity: sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA==}
 
@@ -2545,6 +2632,9 @@ packages:
     resolution: {integrity: sha512-ZX99e6tRweoUXqR+VBrslhda51Nh5MTQwou5tnUDgbtyM0dBgmhEDtWGP/xbKn6hqfPRHujUNwz5fy/wbbhnpw==}
     engines: {node: '>= 0.4'}
 
+  siginfo@2.0.0:
+    resolution: {integrity: sha512-ybx0WO1/8bSBLEWXZvEd7gMW3Sn3JFlW3TvX1nREbDLRNQNaeNN8WK0meBwPdAaOI7TtRRRJn/Es1zhrrCHu7g==}
+
   signal-exit@4.1.0:
     resolution: {integrity: sha512-bzyZ1e88w9O1iNJbKnOlvYTrWPDl46O1bG0D3XInv+9tkPrxrN8jUUTiFlDkkmKWgn1M6CfIA13SuGqOa9Korw==}
     engines: {node: '>=14'}
@@ -2562,10 +2652,16 @@ packages:
     engines: {node: '>= 8'}
     deprecated: The work that was done in this beta branch won't be included in future versions
 
+  stackback@0.0.2:
+    resolution: {integrity: sha512-1XMJE5fQo1jGH6Y/7ebnwPOBEkIEnT4QF32d5R1+VXdXveM0IBMJt8zfaxX1P3QhVwrYe+576+jkANtSS2mBbw==}
+
   statuses@2.0.1:
     resolution: {integrity: sha512-RwNA9Z/7PrK06rYLIzFMlaF+l73iwpzsqRIFgbMLbTcLD6cOao82TaWefPXQvB2fOC4AjuYSEndS7N/mTCbkdQ==}
     engines: {node: '>= 0.8'}
 
+  std-env@3.10.0:
+    resolution: {integrity: sha512-5GS12FdOZNliM5mAOxFRg7Ir0pWz8MdpYm6AY6VPkGpbA7ZzmbzNcBJQ0GPvvyWgcY7QAhCgf9Uy89I03faLkg==}
+
   stop-iteration-iterator@1.1.0:
     resolution: {integrity: sha512-eLoXW/DHyl62zxY4SCaIgnRhuMr6ri4juEYARS8E6sCEqzKpOiE521Ucofdx+KnDZl5xmvGYaaKCk5FEOxJCoQ==}
     engines: {node: '>= 0.4'}
@@ -2654,13 +2750,28 @@ packages:
   thenify@3.3.1:
     resolution: {integrity: sha512-RVZSIV5IG10Hk3enotrhvz0T9em6cyHBLkH/YAZuKqd8hRkKhSfCGIcP2KUY0EPxndzANBmNllzWPwak+bheSw==}
 
+  tinybench@2.9.0:
+    resolution: {integrity: sha512-0+DUvqWMValLmha6lr4kD8iAMK1HzV0/aKnCtWb9v9641TnP/MFb7Pc2bxoxQjTXAErryXVgUOfv2YqNllqGeg==}
+
   tinyexec@0.3.2:
     resolution: {integrity: sha512-KQQR9yN7R5+OSwaK0XQoj22pwHoTlgYqmUscPYoknOoWCWfj/5/ABTMRi69FrKU5ffPVh5QcFikpWJI/P1ocHA==}
 
+  tinyexec@1.0.2:
+    resolution: {integrity: sha512-W/KYk+NFhkmsYpuHq5JykngiOCnxeVL8v8dFnqxSD8qEEdRfXk1SDM6JzNqcERbcGYj9tMrDQBYV9cjgnunFIg==}
+    engines: {node: '>=18'}
+
   tinyglobby@0.2.14:
     resolution: {integrity: sha512-tX5e7OM1HnYr2+a2C/4V0htOcSQcoSTH9KgJnVvNm5zm/cyEWKJ7j7YutsH9CxMdtOkkLFy2AHrMci9IM8IPZQ==}
     engines: {node: '>=12.0.0'}
 
+  tinyglobby@0.2.15:
+    resolution: {integrity: sha512-j2Zq4NyQYG5XMST4cbs02Ak8iJUdxRM0XI5QyxXuZOzKOINmWurp3smXu3y5wDcJrptwpSjgXHzIQxR0omXljQ==}
+    engines: {node: '>=12.0.0'}
+
+  tinyrainbow@3.0.3:
+    resolution: {integrity: sha512-PSkbLUoxOFRzJYjjxHJt9xro7D+iilgMX/C9lawzVuYiIdcihh9DXmVibBe8lmcFrRi/VzlPjBxbN7rH24q8/Q==}
+    engines: {node: '>=14.0.0'}
+
   to-regex-range@5.0.1:
     resolution: {integrity: sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ==}
     engines: {node: '>=8.0'}
@@ -2821,6 +2932,40 @@ packages:
       yaml:
         optional: true
 
+  vitest@4.0.18:
+    resolution: {integrity: sha512-hOQuK7h0FGKgBAas7v0mSAsnvrIgAvWmRFjmzpJ7SwFHH3g1k2u37JtYwOwmEKhK6ZO3v9ggDBBm0La1LCK4uQ==}
+    engines: {node: ^20.0.0 || ^22.0.0 || >=24.0.0}
+    hasBin: true
+    peerDependencies:
+      '@edge-runtime/vm': '*'
+      '@opentelemetry/api': ^1.9.0
+      '@types/node': ^20.0.0 || ^22.0.0 || >=24.0.0
+      '@vitest/browser-playwright': 4.0.18
+      '@vitest/browser-preview': 4.0.18
+      '@vitest/browser-webdriverio': 4.0.18
+      '@vitest/ui': 4.0.18
+      happy-dom: '*'
+      jsdom: '*'
+    peerDependenciesMeta:
+      '@edge-runtime/vm':
+        optional: true
+      '@opentelemetry/api':
+        optional: true
+      '@types/node':
+        optional: true
+      '@vitest/browser-playwright':
+        optional: true
+      '@vitest/browser-preview':
+        optional: true
+      '@vitest/browser-webdriverio':
+        optional: true
+      '@vitest/ui':
+        optional: true
+      happy-dom:
+        optional: true
+      jsdom:
+        optional: true
+
   vscode-uri@3.1.0:
     resolution: {integrity: sha512-/BpdSx+yCQGnCvecbyXdxHDkuk55/G3xwnC0GqY4gmQ3j+A+g8kzzgB4Nk/SINjqn6+waqw3EgbVF2QKExkRxQ==}
 
@@ -2889,6 +3034,11 @@ packages:
     engines: {node: '>= 8'}
     hasBin: true
 
+  why-is-node-running@2.3.0:
+    resolution: {integrity: sha512-hUrmaWBdVDcxvYqnyh09zunKzROWjbZTiNy8dBEjkS7ehEDQibXJ7XvlmtbwuTclUiIyN+CyXQD4Vmko8fNm8w==}
+    engines: {node: '>=8'}
+    hasBin: true
+
   word-wrap@1.2.5:
     resolution: {integrity: sha512-BN22B5eaMMI9UMtjrGd5g5eCYPpCPDUy0FJXbYsaT5zYxjFOckS53SQDE3pWkVoWpHXVb3BrYcEN4Twa55B5cA==}
     engines: {node: '>=0.10.0'}
@@ -3494,6 +3644,8 @@ snapshots:
 
   '@rtsao/scc@1.1.0': {}
 
+  '@standard-schema/spec@1.1.0': {}
+
   '@tanstack/virtual-core@3.13.18': {}
 
   '@tanstack/vue-virtual@3.13.18(vue@3.4.37(typescript@5.5.4))':
@@ -3506,6 +3658,11 @@ snapshots:
       tslib: 2.8.1
     optional: true
 
+  '@types/chai@5.2.3':
+    dependencies:
+      '@types/deep-eql': 4.0.2
+      assertion-error: 2.0.1
+
   '@types/d3-array@3.2.1': {}
 
   '@types/d3-axis@3.0.6':
@@ -3623,6 +3780,8 @@ snapshots:
       '@types/d3-transition': 3.0.9
       '@types/d3-zoom': 3.0.8
 
+  '@types/deep-eql@4.0.2': {}
+
   '@types/estree@1.0.8': {}
 
   '@types/geojson@7946.0.16': {}
@@ -3719,6 +3878,45 @@ snapshots:
       vite: 6.0.7(@types/node@25.0.3)(jiti@2.4.2)(yaml@2.8.1)
       vue: 3.4.37(typescript@5.5.4)
 
+  '@vitest/expect@4.0.18':
+    dependencies:
+      '@standard-schema/spec': 1.1.0
+      '@types/chai': 5.2.3
+      '@vitest/spy': 4.0.18
+      '@vitest/utils': 4.0.18
+      chai: 6.2.2
+      tinyrainbow: 3.0.3
+
+  '@vitest/mocker@4.0.18(vite@6.0.7(@types/node@25.0.3)(jiti@2.4.2)(yaml@2.8.1))':
+    dependencies:
+      '@vitest/spy': 4.0.18
+      estree-walker: 3.0.3
+      magic-string: 0.30.21
+    optionalDependencies:
+      vite: 6.0.7(@types/node@25.0.3)(jiti@2.4.2)(yaml@2.8.1)
+
+  '@vitest/pretty-format@4.0.18':
+    dependencies:
+      tinyrainbow: 3.0.3
+
+  '@vitest/runner@4.0.18':
+    dependencies:
+      '@vitest/utils': 4.0.18
+      pathe: 2.0.3
+
+  '@vitest/snapshot@4.0.18':
+    dependencies:
+      '@vitest/pretty-format': 4.0.18
+      magic-string: 0.30.21
+      pathe: 2.0.3
+
+  '@vitest/spy@4.0.18': {}
+
+  '@vitest/utils@4.0.18':
+    dependencies:
+      '@vitest/pretty-format': 4.0.18
+      tinyrainbow: 3.0.3
+
   '@volar/language-core@2.4.23':
     dependencies:
       '@volar/source-map': 2.4.23
@@ -3933,6 +4131,8 @@ snapshots:
       get-intrinsic: 1.3.0
       is-array-buffer: 3.0.5
 
+  assertion-error@2.0.1: {}
+
   ast-metadata-inferer@0.8.1:
     dependencies:
       '@mdn/browser-compat-data': 5.7.6
@@ -4015,6 +4215,8 @@ snapshots:
 
   caniuse-lite@1.0.30001739: {}
 
+  chai@6.2.2: {}
+
   chalk@4.1.2:
     dependencies:
       ansi-styles: 4.3.0
@@ -4390,6 +4592,8 @@ snapshots:
 
   es-errors@1.3.0: {}
 
+  es-module-lexer@1.7.0: {}
+
   es-object-atoms@1.1.1:
     dependencies:
       es-errors: 1.3.0
@@ -4634,10 +4838,16 @@ snapshots:
 
   estree-walker@2.0.2: {}
 
+  estree-walker@3.0.3:
+    dependencies:
+      '@types/estree': 1.0.8
+
   esutils@2.0.3: {}
 
   etag@1.8.1: {}
 
+  expect-type@1.3.0: {}
+
   express@5.0.0:
     dependencies:
       accepts: 2.0.0
@@ -5127,6 +5337,10 @@ snapshots:
     dependencies:
       '@jridgewell/sourcemap-codec': 1.5.5
 
+  magic-string@0.30.21:
+    dependencies:
+      '@jridgewell/sourcemap-codec': 1.5.5
+
   math-intrinsics@1.1.0: {}
 
   media-typer@1.1.0: {}
@@ -5227,6 +5441,8 @@ snapshots:
       define-properties: 1.2.1
       es-object-atoms: 1.1.1
 
+  obug@2.1.1: {}
+
   on-finished@2.4.1:
     dependencies:
       ee-first: 1.1.1
@@ -5311,6 +5527,8 @@ snapshots:
 
   path-to-regexp@8.2.0: {}
 
+  pathe@2.0.3: {}
+
   picocolors@1.1.1: {}
 
   picomatch@2.3.1: {}
@@ -5632,6 +5850,8 @@ snapshots:
       side-channel-map: 1.0.1
       side-channel-weakmap: 1.0.2
 
+  siginfo@2.0.0: {}
+
   signal-exit@4.1.0: {}
 
   smol-toml@1.6.0: {}
@@ -5642,8 +5862,12 @@ snapshots:
     dependencies:
       whatwg-url: 7.1.0
 
+  stackback@0.0.2: {}
+
   statuses@2.0.1: {}
 
+  std-env@3.10.0: {}
+
   stop-iteration-iterator@1.1.0:
     dependencies:
       es-errors: 1.3.0
@@ -5766,13 +5990,24 @@ snapshots:
     dependencies:
       any-promise: 1.3.0
 
+  tinybench@2.9.0: {}
+
   tinyexec@0.3.2: {}
 
+  tinyexec@1.0.2: {}
+
   tinyglobby@0.2.14:
     dependencies:
       fdir: 6.5.0(picomatch@4.0.3)
       picomatch: 4.0.3
 
+  tinyglobby@0.2.15:
+    dependencies:
+      fdir: 6.5.0(picomatch@4.0.3)
+      picomatch: 4.0.3
+
+  tinyrainbow@3.0.3: {}
+
   to-regex-range@5.0.1:
     dependencies:
       is-number: 7.0.0
@@ -5922,6 +6157,43 @@ snapshots:
       jiti: 2.4.2
       yaml: 2.8.1
 
+  vitest@4.0.18(@types/node@25.0.3)(jiti@2.4.2)(yaml@2.8.1):
+    dependencies:
+      '@vitest/expect': 4.0.18
+      '@vitest/mocker': 4.0.18(vite@6.0.7(@types/node@25.0.3)(jiti@2.4.2)(yaml@2.8.1))
+      '@vitest/pretty-format': 4.0.18
+      '@vitest/runner': 4.0.18
+      '@vitest/snapshot': 4.0.18
+      '@vitest/spy': 4.0.18
+      '@vitest/utils': 4.0.18
+      es-module-lexer: 1.7.0
+      expect-type: 1.3.0
+      magic-string: 0.30.21
+      obug: 2.1.1
+      pathe: 2.0.3
+      picomatch: 4.0.3
+      std-env: 3.10.0
+      tinybench: 2.9.0
+      tinyexec: 1.0.2
+      tinyglobby: 0.2.15
+      tinyrainbow: 3.0.3
+      vite: 6.0.7(@types/node@25.0.3)(jiti@2.4.2)(yaml@2.8.1)
+      why-is-node-running: 2.3.0
+    optionalDependencies:
+      '@types/node': 25.0.3
+    transitivePeerDependencies:
+      - jiti
+      - less
+      - lightningcss
+      - msw
+      - sass
+      - sass-embedded
+      - stylus
+      - sugarss
+      - terser
+      - tsx
+      - yaml
+
   vscode-uri@3.1.0: {}
 
   vue-demi@0.14.10(vue@3.4.37(typescript@5.5.4)):
@@ -6015,6 +6287,11 @@ snapshots:
     dependencies:
       isexe: 2.0.0
 
+  why-is-node-running@2.3.0:
+    dependencies:
+      siginfo: 2.0.0
+      stackback: 0.0.2
+
   word-wrap@1.2.5: {}
 
   wrap-ansi@7.0.0:
diff --git a/vitest.config.ts b/vitest.config.ts
new file mode 100644
index 0000000..c848cf6
--- /dev/null
+++ b/vitest.config.ts
@@ -0,0 +1,8 @@
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+  test: {
+    globals: true,
+    include: ["packages/*/src/**/*.test.ts"],
+  },
+});