diff --git a/.changeset/blue-ghosts-tell.md b/.changeset/blue-ghosts-tell.md
new file mode 100644
index 00000000..ad023632
--- /dev/null
+++ b/.changeset/blue-ghosts-tell.md
@@ -0,0 +1,5 @@
+---
+"svelte-eslint-parser": minor
+---
+
+feat: apply correct type information to `$derived` argument expression
diff --git a/src/parser/typescript/analyze/index.ts b/src/parser/typescript/analyze/index.ts
index d46d0575..d1f25dee 100644
--- a/src/parser/typescript/analyze/index.ts
+++ b/src/parser/typescript/analyze/index.ts
@@ -18,11 +18,17 @@ import type ESTree from "estree";
 import type { SvelteAttribute, SvelteHTMLElement } from "../../../ast";
 import { globals, globalsForRunes } from "../../../parser/globals";
 import type { NormalizedParserOptions } from "../../parser-options";
+import { setParent } from "../set-parent";
 
 export type AnalyzeTypeScriptContext = {
   slots: Set<SvelteHTMLElement>;
 };
 
+type TransformInfo = {
+  node: TSESTree.Node;
+  transform: (ctx: VirtualTypeScriptContext) => void;
+};
+
 /**
  * Analyze TypeScript source code in <script>.
  * Generate virtual code to provide correct type information for Svelte store reference names, scopes, and runes.
@@ -55,7 +61,10 @@ export function analyzeTypeScriptInSvelte(
 
   analyzeRuneVariables(result, ctx);
 
-  analyzeReactiveScopes(result, ctx);
+  applyTransforms(
+    [...analyzeReactiveScopes(result), ...analyzeDollarDerivedScopes(result)],
+    ctx,
+  );
 
   analyzeRenderScopes(code, ctx);
 
@@ -84,6 +93,8 @@ export function analyzeTypeScript(
 
   analyzeRuneVariables(result, ctx);
 
+  applyTransforms([...analyzeDollarDerivedScopes(result)], ctx);
+
   ctx.appendOriginalToEnd();
 
   return ctx;
@@ -390,10 +401,9 @@ function analyzeRuneVariables(
  * Analyze the reactive scopes.
  * Transform source code to provide the correct type information in the `$:` statements.
  */
-function analyzeReactiveScopes(
+function* analyzeReactiveScopes(
   result: TSESParseForESLintResult,
-  ctx: VirtualTypeScriptContext,
-) {
+): Iterable<TransformInfo> {
   const scopeManager = result.scopeManager;
   const throughIds = scopeManager.globalScope!.through.map(
     (reference) => reference.identifier,
@@ -417,17 +427,57 @@ function analyzeReactiveScopes(
               left.range[0] <= id.range[0] && id.range[1] <= left.range[1],
           )
         ) {
-          transformForDeclareReactiveVar(
-            statement,
-            statement.body.expression.left,
-            statement.body.expression,
-            result.ast.tokens!,
-            ctx,
-          );
+          const node = statement;
+          const expression = statement.body.expression;
+          yield {
+            node,
+            transform: (ctx) =>
+              transformForDeclareReactiveVar(
+                node,
+                left,
+                expression,
+                result.ast.tokens!,
+                ctx,
+              ),
+          };
           continue;
         }
       }
-      transformForReactiveStatement(statement, ctx);
+      yield {
+        node: statement,
+        transform: (ctx) => transformForReactiveStatement(statement, ctx),
+      };
+    }
+  }
+}
+
+/**
+ * Analyze the $derived scopes.
+ * Transform source code to provide the correct type information in the `$derived(...)` expression.
+ */
+function* analyzeDollarDerivedScopes(
+  result: TSESParseForESLintResult,
+): Iterable<TransformInfo> {
+  const scopeManager = result.scopeManager;
+  const derivedReferences = scopeManager.globalScope!.through.filter(
+    (reference) => reference.identifier.name === "$derived",
+  );
+  if (!derivedReferences.length) {
+    return;
+  }
+  setParent(result);
+  for (const ref of derivedReferences) {
+    const derived = ref.identifier;
+    if (
+      derived.parent.type === "CallExpression" &&
+      derived.parent.callee === derived &&
+      derived.parent.arguments[0]?.type !== "SpreadElement"
+    ) {
+      const node = derived.parent;
+      yield {
+        node,
+        transform: (ctx) => transformForDollarDerived(node, ctx),
+      };
     }
   }
 }
@@ -464,6 +514,26 @@ function analyzeRenderScopes(
   });
 }
 
+/**
+ * Applies the given transforms.
+ * Note that intersecting transformations are not applied.
+ */
+function applyTransforms(
+  transforms: TransformInfo[],
+  ctx: VirtualTypeScriptContext,
+) {
+  transforms.sort((a, b) => a.node.range[0] - b.node.range[0]);
+
+  let offset = 0;
+  for (const transform of transforms) {
+    const range = transform.node.range;
+    if (offset <= range[0]) {
+      transform.transform(ctx);
+    }
+    offset = range[1];
+  }
+}
+
 /**
  * Transform for `$: id = ...` to `$: let id = ...`
  */
@@ -720,6 +790,76 @@ function transformForReactiveStatement(
   });
 }
 
+/**
+ * Transform for `$derived(expr)` to `$derived((()=>{ return fn(); function fn () { return expr } })())`
+ */
+function transformForDollarDerived(
+  derivedCall: TSESTree.CallExpression,
+  ctx: VirtualTypeScriptContext,
+) {
+  const functionId = ctx.generateUniqueId("$derivedArgument");
+  const expression = derivedCall.arguments[0];
+  ctx.appendOriginal(expression.range[0]);
+  ctx.appendVirtualScript(
+    `(()=>{return ${functionId}();function ${functionId}(){return `,
+  );
+  ctx.appendOriginal(expression.range[1]);
+  ctx.appendVirtualScript(`}})()`);
+
+  ctx.restoreContext.addRestoreExpressionProcess<TSESTree.CallExpression>({
+    target: "CallExpression" as TSESTree.AST_NODE_TYPES.CallExpression,
+    restore:
+      // eslint-disable-next-line complexity -- ignore
+      (node, result) => {
+        if (
+          node.callee.type !== "Identifier" ||
+          node.callee.name !== "$derived"
+        ) {
+          return false;
+        }
+        const arg = node.arguments[0];
+        if (
+          !arg ||
+          arg.type !== "CallExpression" ||
+          arg.arguments.length !== 0 ||
+          arg.callee.type !== "ArrowFunctionExpression" ||
+          arg.callee.body.type !== "BlockStatement" ||
+          arg.callee.body.body.length !== 2 ||
+          arg.callee.body.body[0].type !== "ReturnStatement" ||
+          arg.callee.body.body[0].argument?.type !== "CallExpression" ||
+          arg.callee.body.body[0].argument.callee.type !== "Identifier" ||
+          arg.callee.body.body[0].argument.callee.name !== functionId ||
+          arg.callee.body.body[1].type !== "FunctionDeclaration" ||
+          arg.callee.body.body[1].id.name !== functionId
+        ) {
+          return false;
+        }
+        const fnNode = arg.callee.body.body[1];
+        if (
+          fnNode.body.body.length !== 1 ||
+          fnNode.body.body[0].type !== "ReturnStatement" ||
+          !fnNode.body.body[0].argument
+        ) {
+          return false;
+        }
+
+        const expr = fnNode.body.body[0].argument;
+
+        node.arguments[0] = expr;
+        expr.parent = node;
+
+        const scopeManager = result.scopeManager as ScopeManager;
+        removeFunctionScope(arg.callee.body.body[1], scopeManager);
+        removeIdentifierReference(
+          arg.callee.body.body[0].argument.callee,
+          scopeManager.acquire(arg.callee)!,
+        );
+        removeFunctionScope(arg.callee, scopeManager);
+        return true;
+      },
+  });
+}
+
 /** Remove function scope and marge child scopes to upper scope */
 function removeFunctionScope(
   node:
diff --git a/src/parser/typescript/index.ts b/src/parser/typescript/index.ts
index f75bb9be..fce42761 100644
--- a/src/parser/typescript/index.ts
+++ b/src/parser/typescript/index.ts
@@ -1,9 +1,9 @@
 import type { ESLintExtendedProgram } from "..";
-import { traverseNodes } from "../..";
 import type { NormalizedParserOptions } from "../parser-options";
 import { parseScript, parseScriptInSvelte } from "../script";
 import type { AnalyzeTypeScriptContext } from "./analyze";
 import { analyzeTypeScript, analyzeTypeScriptInSvelte } from "./analyze";
+import { setParent } from "./set-parent";
 import type { TSESParseForESLintResult } from "./types";
 
 /**
@@ -34,15 +34,7 @@ export function parseTypeScript(
   const tsCtx = analyzeTypeScript(code, attrs, parserOptions);
 
   const result = parseScript(tsCtx.script, attrs, parserOptions);
-  traverseNodes(result.ast, {
-    visitorKeys: result.visitorKeys,
-    enterNode(node, parent) {
-      (node as any).parent = parent;
-    },
-    leaveNode() {
-      //
-    },
-  });
+  setParent(result);
 
   tsCtx.restoreContext.restore(result as unknown as TSESParseForESLintResult);
 
diff --git a/src/parser/typescript/restore.ts b/src/parser/typescript/restore.ts
index cc3c8951..fd21cd89 100644
--- a/src/parser/typescript/restore.ts
+++ b/src/parser/typescript/restore.ts
@@ -17,6 +17,20 @@ type RestoreStatementProcess = (
   node: TSESTree.Statement,
   result: TSESParseForESLintResult,
 ) => boolean;
+/**
+ * A function that restores the expression.
+ * @param node The node to restore.
+ * @param result The result of parsing.
+ * @returns
+ *   If `false`, it indicates that the specified node was not processed.
+ *
+ *   If `true`, it indicates that the specified node was processed for processing.
+ *   This process will no longer be called.
+ */
+type RestoreExpressionProcess<T extends TSESTree.Expression> = {
+  target: T["type"];
+  restore: (node: T, result: TSESParseForESLintResult) => boolean;
+};
 
 export class RestoreContext {
   private readonly originalLocs: LinesAndColumns;
@@ -27,6 +41,9 @@ export class RestoreContext {
 
   private readonly restoreStatementProcesses: RestoreStatementProcess[] = [];
 
+  private readonly restoreExpressionProcesses: RestoreExpressionProcess<TSESTree.Expression>[] =
+    [];
+
   public constructor(code: string) {
     this.originalLocs = new LinesAndColumns(code);
   }
@@ -35,6 +52,12 @@ export class RestoreContext {
     this.restoreStatementProcesses.push(process);
   }
 
+  public addRestoreExpressionProcess<T extends TSESTree.Expression>(
+    process: RestoreExpressionProcess<T>,
+  ): void {
+    this.restoreExpressionProcesses.push(process as never);
+  }
+
   public addOffset(offset: { original: number; dist: number }): void {
     this.offsets.push(offset);
   }
@@ -61,6 +84,7 @@ export class RestoreContext {
     });
 
     restoreStatements(result, this.restoreStatementProcesses);
+    restoreExpressions(result, this.restoreExpressionProcesses);
 
     // Adjust program node location
     const firstOffset = Math.min(
@@ -151,9 +175,10 @@ function remapLocations(
   // remap locations
   traverseNodes(result.ast, {
     visitorKeys: result.visitorKeys,
-    enterNode: (node, p) => {
+    enterNode: (node, parent) => {
+      (node as any).parent = parent;
       if (!traversed.has(node)) {
-        traversed.set(node, p);
+        traversed.set(node, parent);
 
         remapLocation(node);
       }
@@ -194,3 +219,28 @@ function restoreStatements(
     }
   }
 }
+
+/** Restore expression nodes */
+function restoreExpressions(
+  result: TSESParseForESLintResult,
+  restoreExpressionProcesses: RestoreExpressionProcess<TSESTree.Expression>[],
+) {
+  if (restoreExpressionProcesses.length === 0) return;
+  const restoreExpressionProcessesSet = new Set(restoreExpressionProcesses);
+  traverseNodes(result.ast, {
+    visitorKeys: result.visitorKeys,
+    enterNode(node) {
+      for (const proc of restoreExpressionProcessesSet) {
+        if (proc.target === node.type) {
+          if (proc.restore(node as any, result)) {
+            restoreExpressionProcessesSet.delete(proc);
+          }
+          break;
+        }
+      }
+    },
+    leaveNode() {
+      /* noop */
+    },
+  });
+}
diff --git a/src/parser/typescript/set-parent.ts b/src/parser/typescript/set-parent.ts
new file mode 100644
index 00000000..01eb102a
--- /dev/null
+++ b/src/parser/typescript/set-parent.ts
@@ -0,0 +1,20 @@
+import type { ESLintExtendedProgram } from "..";
+import { traverseNodes } from "../..";
+import type { TSESParseForESLintResult } from "./types";
+
+export function setParent(
+  result: ESLintExtendedProgram | TSESParseForESLintResult,
+): void {
+  if (result.ast.body.some((node) => (node as any).parent)) {
+    return;
+  }
+  traverseNodes(result.ast, {
+    visitorKeys: result.visitorKeys,
+    enterNode(node, parent) {
+      (node as any).parent = parent;
+    },
+    leaveNode() {
+      // noop
+    },
+  });
+}
diff --git a/tests/fixtures/integrations/type-info-tests/$derived-input.svelte b/tests/fixtures/integrations/type-info-tests/$derived-input.svelte
new file mode 100644
index 00000000..1799917a
--- /dev/null
+++ b/tests/fixtures/integrations/type-info-tests/$derived-input.svelte
@@ -0,0 +1,17 @@
+<script lang="ts">
+    type Info = { foo: number };
+    let x: Info | null = { foo: 42 };
+    const get = () => "hello";
+
+    x = null;
+    const y = $derived(x);
+    const z = $derived(fn(y.foo));
+    const foo = $derived(get);
+
+    function fn(a: number): number {
+        return a;
+    }
+</script>
+
+<input title={z} bind:value={x}>
+{foo()}
diff --git a/tests/fixtures/integrations/type-info-tests/$derived-output.json b/tests/fixtures/integrations/type-info-tests/$derived-output.json
new file mode 100644
index 00000000..0637a088
--- /dev/null
+++ b/tests/fixtures/integrations/type-info-tests/$derived-output.json
@@ -0,0 +1 @@
+[]
\ No newline at end of file
diff --git a/tests/fixtures/integrations/type-info-tests/$derived-requirements.json b/tests/fixtures/integrations/type-info-tests/$derived-requirements.json
new file mode 100644
index 00000000..809a4e1f
--- /dev/null
+++ b/tests/fixtures/integrations/type-info-tests/$derived-requirements.json
@@ -0,0 +1,5 @@
+{
+    "parse": {
+        "svelte": ">=5.0.0-0"
+    }
+}
\ No newline at end of file
diff --git a/tests/fixtures/integrations/type-info-tests/$derived-setup.ts b/tests/fixtures/integrations/type-info-tests/$derived-setup.ts
new file mode 100644
index 00000000..d53704e5
--- /dev/null
+++ b/tests/fixtures/integrations/type-info-tests/$derived-setup.ts
@@ -0,0 +1,47 @@
+/* eslint eslint-comments/require-description: 0, @typescript-eslint/explicit-module-boundary-types: 0 */
+import type { Linter } from "eslint";
+import { generateParserOptions } from "../../../src/parser/test-utils";
+import { rules } from "@typescript-eslint/eslint-plugin";
+export function setupLinter(linter: Linter) {
+  linter.defineRule(
+    "@typescript-eslint/no-unsafe-argument",
+    rules["no-unsafe-argument"] as never,
+  );
+  linter.defineRule(
+    "@typescript-eslint/no-unsafe-assignment",
+    rules["no-unsafe-assignment"] as never,
+  );
+  linter.defineRule(
+    "@typescript-eslint/no-unsafe-call",
+    rules["no-unsafe-call"] as never,
+  );
+  linter.defineRule(
+    "@typescript-eslint/no-unsafe-member-access",
+    rules["no-unsafe-member-access"] as never,
+  );
+  linter.defineRule(
+    "@typescript-eslint/no-unsafe-return",
+    rules["no-unsafe-return"] as never,
+  );
+}
+
+export function getConfig() {
+  return {
+    parser: "svelte-eslint-parser",
+    parserOptions: {
+      ...generateParserOptions(),
+      svelteFeatures: { runes: true },
+    },
+    rules: {
+      "@typescript-eslint/no-unsafe-argument": "error",
+      "@typescript-eslint/no-unsafe-assignment": "error",
+      "@typescript-eslint/no-unsafe-call": "error",
+      "@typescript-eslint/no-unsafe-member-access": "error",
+      "@typescript-eslint/no-unsafe-return": "error",
+    },
+    env: {
+      browser: true,
+      es2021: true,
+    },
+  };
+}
diff --git a/tests/fixtures/integrations/type-info-tests/$derived-ts-input.svelte.ts b/tests/fixtures/integrations/type-info-tests/$derived-ts-input.svelte.ts
new file mode 100644
index 00000000..7b17de2c
--- /dev/null
+++ b/tests/fixtures/integrations/type-info-tests/$derived-ts-input.svelte.ts
@@ -0,0 +1,12 @@
+type Info = { foo: number };
+let x: Info | null = { foo: 42 };
+const get = () => "hello";
+
+x = null;
+const y = $derived(x);
+const z = $derived(fn(y.foo));
+const foo = $derived(get);
+
+function fn(a: number): number {
+  return a;
+}
diff --git a/tests/fixtures/integrations/type-info-tests/$derived-ts-output.json b/tests/fixtures/integrations/type-info-tests/$derived-ts-output.json
new file mode 100644
index 00000000..0637a088
--- /dev/null
+++ b/tests/fixtures/integrations/type-info-tests/$derived-ts-output.json
@@ -0,0 +1 @@
+[]
\ No newline at end of file
diff --git a/tests/fixtures/integrations/type-info-tests/$derived-ts-requirements.json b/tests/fixtures/integrations/type-info-tests/$derived-ts-requirements.json
new file mode 100644
index 00000000..809a4e1f
--- /dev/null
+++ b/tests/fixtures/integrations/type-info-tests/$derived-ts-requirements.json
@@ -0,0 +1,5 @@
+{
+    "parse": {
+        "svelte": ">=5.0.0-0"
+    }
+}
\ No newline at end of file
diff --git a/tests/fixtures/integrations/type-info-tests/$derived-ts-setup.ts b/tests/fixtures/integrations/type-info-tests/$derived-ts-setup.ts
new file mode 100644
index 00000000..d53704e5
--- /dev/null
+++ b/tests/fixtures/integrations/type-info-tests/$derived-ts-setup.ts
@@ -0,0 +1,47 @@
+/* eslint eslint-comments/require-description: 0, @typescript-eslint/explicit-module-boundary-types: 0 */
+import type { Linter } from "eslint";
+import { generateParserOptions } from "../../../src/parser/test-utils";
+import { rules } from "@typescript-eslint/eslint-plugin";
+export function setupLinter(linter: Linter) {
+  linter.defineRule(
+    "@typescript-eslint/no-unsafe-argument",
+    rules["no-unsafe-argument"] as never,
+  );
+  linter.defineRule(
+    "@typescript-eslint/no-unsafe-assignment",
+    rules["no-unsafe-assignment"] as never,
+  );
+  linter.defineRule(
+    "@typescript-eslint/no-unsafe-call",
+    rules["no-unsafe-call"] as never,
+  );
+  linter.defineRule(
+    "@typescript-eslint/no-unsafe-member-access",
+    rules["no-unsafe-member-access"] as never,
+  );
+  linter.defineRule(
+    "@typescript-eslint/no-unsafe-return",
+    rules["no-unsafe-return"] as never,
+  );
+}
+
+export function getConfig() {
+  return {
+    parser: "svelte-eslint-parser",
+    parserOptions: {
+      ...generateParserOptions(),
+      svelteFeatures: { runes: true },
+    },
+    rules: {
+      "@typescript-eslint/no-unsafe-argument": "error",
+      "@typescript-eslint/no-unsafe-assignment": "error",
+      "@typescript-eslint/no-unsafe-call": "error",
+      "@typescript-eslint/no-unsafe-member-access": "error",
+      "@typescript-eslint/no-unsafe-return": "error",
+    },
+    env: {
+      browser: true,
+      es2021: true,
+    },
+  };
+}
diff --git a/tests/fixtures/integrations/type-info-tests/$derived2-input.svelte b/tests/fixtures/integrations/type-info-tests/$derived2-input.svelte
new file mode 100644
index 00000000..07693c79
--- /dev/null
+++ b/tests/fixtures/integrations/type-info-tests/$derived2-input.svelte
@@ -0,0 +1,15 @@
+<script lang="ts">
+  type Info = { foo: number };
+  let i: Info | null = null;
+  export const d = $derived(i?.foo ? fn(i.foo) : null);
+
+  setTimeout(() => {
+    i = { foo: 42 };
+  }, 10);
+
+  function fn(a: number): number {
+    return a;
+  }
+</script>
+
+{d}
diff --git a/tests/fixtures/integrations/type-info-tests/$derived2-output.json b/tests/fixtures/integrations/type-info-tests/$derived2-output.json
new file mode 100644
index 00000000..0637a088
--- /dev/null
+++ b/tests/fixtures/integrations/type-info-tests/$derived2-output.json
@@ -0,0 +1 @@
+[]
\ No newline at end of file
diff --git a/tests/fixtures/integrations/type-info-tests/$derived2-requirements.json b/tests/fixtures/integrations/type-info-tests/$derived2-requirements.json
new file mode 100644
index 00000000..809a4e1f
--- /dev/null
+++ b/tests/fixtures/integrations/type-info-tests/$derived2-requirements.json
@@ -0,0 +1,5 @@
+{
+    "parse": {
+        "svelte": ">=5.0.0-0"
+    }
+}
\ No newline at end of file
diff --git a/tests/fixtures/integrations/type-info-tests/$derived2-setup.ts b/tests/fixtures/integrations/type-info-tests/$derived2-setup.ts
new file mode 100644
index 00000000..d53704e5
--- /dev/null
+++ b/tests/fixtures/integrations/type-info-tests/$derived2-setup.ts
@@ -0,0 +1,47 @@
+/* eslint eslint-comments/require-description: 0, @typescript-eslint/explicit-module-boundary-types: 0 */
+import type { Linter } from "eslint";
+import { generateParserOptions } from "../../../src/parser/test-utils";
+import { rules } from "@typescript-eslint/eslint-plugin";
+export function setupLinter(linter: Linter) {
+  linter.defineRule(
+    "@typescript-eslint/no-unsafe-argument",
+    rules["no-unsafe-argument"] as never,
+  );
+  linter.defineRule(
+    "@typescript-eslint/no-unsafe-assignment",
+    rules["no-unsafe-assignment"] as never,
+  );
+  linter.defineRule(
+    "@typescript-eslint/no-unsafe-call",
+    rules["no-unsafe-call"] as never,
+  );
+  linter.defineRule(
+    "@typescript-eslint/no-unsafe-member-access",
+    rules["no-unsafe-member-access"] as never,
+  );
+  linter.defineRule(
+    "@typescript-eslint/no-unsafe-return",
+    rules["no-unsafe-return"] as never,
+  );
+}
+
+export function getConfig() {
+  return {
+    parser: "svelte-eslint-parser",
+    parserOptions: {
+      ...generateParserOptions(),
+      svelteFeatures: { runes: true },
+    },
+    rules: {
+      "@typescript-eslint/no-unsafe-argument": "error",
+      "@typescript-eslint/no-unsafe-assignment": "error",
+      "@typescript-eslint/no-unsafe-call": "error",
+      "@typescript-eslint/no-unsafe-member-access": "error",
+      "@typescript-eslint/no-unsafe-return": "error",
+    },
+    env: {
+      browser: true,
+      es2021: true,
+    },
+  };
+}
diff --git a/tests/fixtures/integrations/type-info-tests/$derived2-ts-input.svelte.ts b/tests/fixtures/integrations/type-info-tests/$derived2-ts-input.svelte.ts
new file mode 100644
index 00000000..9bc7dbbb
--- /dev/null
+++ b/tests/fixtures/integrations/type-info-tests/$derived2-ts-input.svelte.ts
@@ -0,0 +1,18 @@
+export type Info = { n: number };
+export function foo() {
+  let a: Info | null = $state(null);
+  a = null; // *
+  const d = $derived(a?.n ? fn(a.n) : null);
+  return {
+    get d() {
+      return d;
+    },
+    set(b: Info | null) {
+      a = b;
+    },
+  };
+
+  function fn(n: number) {
+    return n * 2;
+  }
+}
diff --git a/tests/fixtures/integrations/type-info-tests/$derived2-ts-output.json b/tests/fixtures/integrations/type-info-tests/$derived2-ts-output.json
new file mode 100644
index 00000000..0637a088
--- /dev/null
+++ b/tests/fixtures/integrations/type-info-tests/$derived2-ts-output.json
@@ -0,0 +1 @@
+[]
\ No newline at end of file
diff --git a/tests/fixtures/integrations/type-info-tests/$derived2-ts-requirements.json b/tests/fixtures/integrations/type-info-tests/$derived2-ts-requirements.json
new file mode 100644
index 00000000..809a4e1f
--- /dev/null
+++ b/tests/fixtures/integrations/type-info-tests/$derived2-ts-requirements.json
@@ -0,0 +1,5 @@
+{
+    "parse": {
+        "svelte": ">=5.0.0-0"
+    }
+}
\ No newline at end of file
diff --git a/tests/fixtures/integrations/type-info-tests/$derived2-ts-setup.ts b/tests/fixtures/integrations/type-info-tests/$derived2-ts-setup.ts
new file mode 100644
index 00000000..b1b1f599
--- /dev/null
+++ b/tests/fixtures/integrations/type-info-tests/$derived2-ts-setup.ts
@@ -0,0 +1,47 @@
+/* eslint eslint-comments/require-description: 0, @typescript-eslint/explicit-module-boundary-types: 0 */
+import type { Linter } from "eslint";
+import { generateParserOptions } from "../../../src/parser/test-utils";
+import { rules } from "@typescript-eslint/eslint-plugin";
+export function setupLinter(linter: Linter) {
+  linter.defineRule(
+    "@typescript-eslint/no-unsafe-argument",
+    rules["no-unsafe-argument"] as never
+  );
+  linter.defineRule(
+    "@typescript-eslint/no-unsafe-assignment",
+    rules["no-unsafe-assignment"] as never
+  );
+  linter.defineRule(
+    "@typescript-eslint/no-unsafe-call",
+    rules["no-unsafe-call"] as never
+  );
+  linter.defineRule(
+    "@typescript-eslint/no-unsafe-member-access",
+    rules["no-unsafe-member-access"] as never
+  );
+  linter.defineRule(
+    "@typescript-eslint/no-unsafe-return",
+    rules["no-unsafe-return"] as never
+  );
+}
+
+export function getConfig() {
+  return {
+    parser: "svelte-eslint-parser",
+    parserOptions: {
+      ...generateParserOptions(),
+      svelteFeatures: { runes: true },
+    },
+    rules: {
+      "@typescript-eslint/no-unsafe-argument": "error",
+      "@typescript-eslint/no-unsafe-assignment": "error",
+      "@typescript-eslint/no-unsafe-call": "error",
+      "@typescript-eslint/no-unsafe-member-access": "error",
+      "@typescript-eslint/no-unsafe-return": "error",
+    },
+    env: {
+      browser: true,
+      es2021: true,
+    },
+  };
+}
diff --git a/tests/fixtures/parser/ast/svelte5/ts-$props01-type-output.svelte b/tests/fixtures/parser/ast/svelte5/ts-$props01-type-output.svelte
index feba88d5..619009a9 100644
--- a/tests/fixtures/parser/ast/svelte5/ts-$props01-type-output.svelte
+++ b/tests/fixtures/parser/ast/svelte5/ts-$props01-type-output.svelte
@@ -9,6 +9,6 @@
 </script>
 
 {a} <!-- a: number -->
-{b} <!-- b: Promise<{ x: number; }> -->
-{c} <!-- c: Promise<{ x: number; }> -->
+{b} <!-- b: string -->
+{c} <!-- c: boolean -->
 {everythingElse} <!-- everythingElse: { d: number; } -->
diff --git a/tests/fixtures/parser/ast/ts-use01-type-output.svelte b/tests/fixtures/parser/ast/ts-use01-type-output.svelte
index 11d40e51..9aaf404e 100644
--- a/tests/fixtures/parser/ast/ts-use01-type-output.svelte
+++ b/tests/fixtures/parser/ast/ts-use01-type-output.svelte
@@ -1,6 +1,6 @@
 <script lang="ts">
   type MyActionParam = () => (p: { foo: number }) => void; // MyActionParam: MyActionParam, p: { foo: number; }
-  function myAction(_node: HTMLElement, params: MyActionParam) { // myAction: { (_node: HTMLElement, params: MyActionParam): { destroy: () => void; }; (_node: HTMLElement, params: MyActionParam): { ...; }; }, _node: HTMLElement, params: MyActionParam
+  function myAction(_node: HTMLElement, params: MyActionParam) { // myAction: (_node: HTMLElement, params: MyActionParam) => { destroy: () => void; }, _node: HTMLElement, params: MyActionParam
     const result = params(); // result: (p: { foo: number; }) => void, params(): (p: { foo: number; }) => void
     result({ foo: 1 }); // result({ foo: 1 }): void
     return {
@@ -10,7 +10,7 @@
 </script>
 
 <div
-  use:myAction={() => { // myAction: { (_node: HTMLElement, params: MyActionParam): { destroy: () => void; }; (_node: HTMLElement, params: MyActionParam): { ...; }; }
+  use:myAction={() => { // myAction: (_node: HTMLElement, params: MyActionParam) => { destroy: () => void; }
     return (param) => { // param: { foo: number; }
       param.foo; // param.foo: number
     };
diff --git a/tests/fixtures/tsconfig.test.json b/tests/fixtures/tsconfig.test.json
index 86521018..e5167dc3 100644
--- a/tests/fixtures/tsconfig.test.json
+++ b/tests/fixtures/tsconfig.test.json
@@ -1,6 +1,7 @@
 {
   "compilerOptions": {
     "strict": true,
-    "module": "commonjs"
+    "module": "Node16",
+    "moduleResolution": "Node16",
   }
 }
\ No newline at end of file
diff --git a/tests/src/integrations.ts b/tests/src/integrations.ts
index 23ce1992..7112558b 100644
--- a/tests/src/integrations.ts
+++ b/tests/src/integrations.ts
@@ -21,12 +21,19 @@ function createLinter() {
 }
 
 describe("Integration tests.", () => {
-  for (const { input, inputFileName, outputFileName, config } of listupFixtures(
-    FIXTURE_ROOT,
-  )) {
+  for (const {
+    input,
+    inputFileName,
+    outputFileName,
+    config,
+    meetRequirements,
+  } of listupFixtures(FIXTURE_ROOT)) {
+    if (!meetRequirements("parse")) {
+      continue;
+    }
     it(inputFileName, () => {
       const setupFileName = inputFileName.replace(
-        /input\.svelte$/u,
+        /input\.svelte(?:\.[jt]s)?$/u,
         "setup.ts",
       );
       const setup = fs.existsSync(setupFileName)
diff --git a/tools/update-fixtures.ts b/tools/update-fixtures.ts
index 96c3340a..51d165ca 100644
--- a/tools/update-fixtures.ts
+++ b/tools/update-fixtures.ts
@@ -14,7 +14,6 @@ import {
 } from "../tests/src/parser/test-utils";
 import type ts from "typescript";
 import type ESTree from "estree";
-import * as tsESLintParser from "@typescript-eslint/parser";
 import type { SourceLocation } from "../src/ast";
 
 const ERROR_FIXTURE_ROOT = path.resolve(
@@ -46,21 +45,10 @@ const RULES = [
   "template-curly-spacing",
 ];
 
-let beforeFilePath: string | undefined;
-
 /**
  * Parse
  */
 function parse(code: string, filePath: string, config: any) {
-  if (beforeFilePath) {
-    // Clear type info cache
-    tsESLintParser.parseForESLint(
-      "",
-      generateParserOptions({ filePath: beforeFilePath }, config),
-    );
-  }
-
-  beforeFilePath = filePath;
   return parseForESLint(code, generateParserOptions({ filePath }, config));
 }