diff --git a/.changeset/tasty-wings-bake.md b/.changeset/tasty-wings-bake.md
new file mode 100644
index 000000000000..06314fc72d03
--- /dev/null
+++ b/.changeset/tasty-wings-bake.md
@@ -0,0 +1,5 @@
+---
+"@biomejs/biome": patch
+---
+
+Fixed [#6316](https://github.com/biomejs/biome/issues/6316): Biome now resolves Svelte `$store` references to the underlying `store` binding in semantic analysis, preventing false `noUndeclaredVariables` diagnostics when the store is declared.
diff --git a/crates/biome_cli/tests/cases/handle_svelte_files.rs b/crates/biome_cli/tests/cases/handle_svelte_files.rs
index df5a00040be9..de2742db361e 100644
--- a/crates/biome_cli/tests/cases/handle_svelte_files.rs
+++ b/crates/biome_cli/tests/cases/handle_svelte_files.rs
@@ -40,6 +40,38 @@ var foo: string = "";
 </script>
 <div></div>"#;
 
+// In Svelte, `writable(...)` creates a store binding (`count`), and `$count` is the
+// auto-subscription syntax that reads the store value.
+// This test verifies `$count` resolves through `count`, while `$missing` stays undeclared.
+const SVELTE_STORE_DEREFERENCE_FILE: &str = r#"<script>
+import { writable } from "svelte/store";
+const count = writable(1);
+$count;
+$missing;
+</script>
+<div></div>"#;
+
+const SVELTE_MODULE_STORE_DEREFERENCE_FILE: &str = r#"import { writable } from "svelte/store";
+const count = writable(1);
+$count;
+$missing;"#;
+
+const SVELTE_JS_MODULE_STORE_DEREFERENCE_FILE: &str = r#"import { writable } from "svelte/store";
+const count = writable(1);
+$count;
+$missing;"#;
+
+const SVELTE_MODULE_TYPE_ONLY_BINDING_DEREFERENCE_FILE: &str = r#"type count = number;
+$count;"#;
+
+// Regression guard for `.svelte` + `<script lang="ts">` + `checkTypes: true`.
+// `PromiseLike` comes from TypeScript lib globals and must not be reported as undeclared.
+// If source-type inference regresses to JavaScript, this test starts failing.
+const SVELTE_TS_SCRIPT_TYPE_GLOBAL_FILE: &str = r#"<script lang="ts">
+type B<T> = PromiseLike<T>;
+</script>
+<div></div>"#;
+
 #[test]
 fn sorts_imports_check() {
     let fs = MemoryFileSystem::default();
@@ -542,3 +574,643 @@ fn check_stdin_write_unsafe_successfully() {
         result,
     ));
 }
+
+// `.svelte` component path: `$count` should resolve via extracted `<script>` bindings.
+#[test]
+fn no_undeclared_variables_handles_svelte_store_dereference() {
+    let fs = MemoryFileSystem::default();
+    let mut console = BufferConsole::default();
+
+    let file = Utf8Path::new("file.svelte");
+    fs.insert(file.into(), SVELTE_STORE_DEREFERENCE_FILE.as_bytes());
+
+    let (fs, result) = run_cli(
+        fs,
+        &mut console,
+        Args::from(["lint", "--only=noUndeclaredVariables", file.as_str()].as_slice()),
+    );
+
+    assert!(result.is_err(), "run_cli returned {result:?}");
+
+    assert_cli_snapshot(SnapshotPayload::new(
+        module_path!(),
+        "no_undeclared_variables_handles_svelte_store_dereference",
+        fs,
+        console,
+        result,
+    ));
+}
+
+// `.svelte.ts` source-module path: `$count` should resolve through the `count` store binding,
+// and `$missing` should stay undeclared.
+#[test]
+fn no_undeclared_variables_handles_svelte_module_store_dereference() {
+    let fs = MemoryFileSystem::default();
+    let mut console = BufferConsole::default();
+
+    let file = Utf8Path::new("file.svelte.ts");
+    fs.insert(file.into(), SVELTE_MODULE_STORE_DEREFERENCE_FILE.as_bytes());
+
+    let (fs, result) = run_cli(
+        fs,
+        &mut console,
+        Args::from(["lint", "--only=noUndeclaredVariables", file.as_str()].as_slice()),
+    );
+
+    assert!(result.is_err(), "run_cli returned {result:?}");
+
+    assert_cli_snapshot(SnapshotPayload::new(
+        module_path!(),
+        "no_undeclared_variables_handles_svelte_module_store_dereference",
+        fs,
+        console,
+        result,
+    ));
+}
+
+// Type-only bindings must not satisfy `$count` store dereference resolution.
+#[test]
+fn no_undeclared_variables_handles_svelte_module_type_only_store_dereference() {
+    let fs = MemoryFileSystem::default();
+    let mut console = BufferConsole::default();
+
+    let file = Utf8Path::new("file.svelte.ts");
+    fs.insert(
+        file.into(),
+        SVELTE_MODULE_TYPE_ONLY_BINDING_DEREFERENCE_FILE.as_bytes(),
+    );
+
+    let (fs, result) = run_cli(
+        fs,
+        &mut console,
+        Args::from(["lint", "--only=noUndeclaredVariables", file.as_str()].as_slice()),
+    );
+
+    assert!(result.is_err(), "run_cli returned {result:?}");
+
+    assert_cli_snapshot(SnapshotPayload::new(
+        module_path!(),
+        "no_undeclared_variables_handles_svelte_module_type_only_store_dereference",
+        fs,
+        console,
+        result,
+    ));
+}
+
+// `.svelte.js` source-module path: `$count` should resolve through the `count` store binding,
+// and `$missing` should stay undeclared.
+#[test]
+fn no_undeclared_variables_handles_svelte_js_module_store_dereference() {
+    let fs = MemoryFileSystem::default();
+    let mut console = BufferConsole::default();
+
+    let file = Utf8Path::new("file.svelte.js");
+    fs.insert(
+        file.into(),
+        SVELTE_JS_MODULE_STORE_DEREFERENCE_FILE.as_bytes(),
+    );
+
+    let (fs, result) = run_cli(
+        fs,
+        &mut console,
+        Args::from(["lint", "--only=noUndeclaredVariables", file.as_str()].as_slice()),
+    );
+
+    assert!(result.is_err(), "run_cli returned {result:?}");
+
+    assert_cli_snapshot(SnapshotPayload::new(
+        module_path!(),
+        "no_undeclared_variables_handles_svelte_js_module_store_dereference",
+        fs,
+        console,
+        result,
+    ));
+}
+
+// `.svelte` + `<script lang="ts">` + `checkTypes`: TS globals (e.g. `PromiseLike`) must stay recognized.
+#[test]
+fn no_undeclared_variables_check_types_handles_svelte_ts_script_globals() {
+    let fs = MemoryFileSystem::default();
+    let mut console = BufferConsole::default();
+    fs.insert(
+        "biome.json".into(),
+        r#"{
+  "linter": {
+    "rules": {
+      "correctness": {
+        "noUndeclaredVariables": {
+          "level": "error",
+          "options": {
+            "checkTypes": true
+          }
+        }
+      }
+    }
+  }
+}"#
+        .as_bytes(),
+    );
+
+    let file = Utf8Path::new("file.svelte");
+    fs.insert(file.into(), SVELTE_TS_SCRIPT_TYPE_GLOBAL_FILE.as_bytes());
+
+    let (fs, result) = run_cli(
+        fs,
+        &mut console,
+        Args::from(["lint", "--only=noUndeclaredVariables", file.as_str()].as_slice()),
+    );
+
+    assert!(result.is_ok(), "run_cli returned {result:?}");
+
+    assert_cli_snapshot(SnapshotPayload::new(
+        module_path!(),
+        "no_undeclared_variables_check_types_handles_svelte_ts_script_globals",
+        fs,
+        console,
+        result,
+    ));
+}
+
+#[test]
+fn embedded_bindings_are_tracked_correctly() {
+    let fs = MemoryFileSystem::default();
+    let mut console = BufferConsole::default();
+
+    fs.insert(
+        "biome.json".into(),
+        r#"{ "html": { "linter": {"enabled": true}, "experimentalFullSupportEnabled": true } }"#
+            .as_bytes(),
+    );
+
+    let file = Utf8Path::new("file.svelte");
+    fs.insert(
+        file.into(),
+        r#"<script>
+import { Component } from "./component.svelte";
+let hello = "Hello World";
+let array = [];
+let props = [];
+</script>
+
+<html>
+    <span>{hello}</span>
+    <span>{notDefined}</span>
+    {#each array as item}
+    {/each}
+    <Component />
+    <input {...props} />
+</html>
+"#
+        .as_bytes(),
+    );
+
+    let (fs, result) = run_cli(
+        fs,
+        &mut console,
+        Args::from(["lint", "--only=noUnusedVariables", file.as_str()].as_slice()),
+    );
+
+    assert!(result.is_ok(), "run_cli returned {result:?}");
+
+    assert_cli_snapshot(SnapshotPayload::new(
+        module_path!(),
+        "embedded_bindings_are_tracked_correctly",
+        fs,
+        console,
+        result,
+    ));
+}
+
+#[test]
+fn use_const_not_triggered_in_snippet_sources() {
+    let fs = MemoryFileSystem::default();
+    let mut console = BufferConsole::default();
+
+    fs.insert(
+        "biome.json".into(),
+        r#"{ "html": { "linter": {"enabled": true}, "experimentalFullSupportEnabled": true } }"#
+            .as_bytes(),
+    );
+
+    let file = Utf8Path::new("file.svelte");
+    fs.insert(
+        file.into(),
+        r#"<script>
+let hello = "Hello World";
+</script>
+
+<html>
+    <span>{hello}</span>
+</html>
+"#
+        .as_bytes(),
+    );
+
+    let (fs, result) = run_cli(
+        fs,
+        &mut console,
+        Args::from(["lint", "--only=useConst", file.as_str()].as_slice()),
+    );
+
+    assert!(result.is_ok(), "run_cli returned {result:?}");
+
+    assert_cli_snapshot(SnapshotPayload::new(
+        module_path!(),
+        "use_const_not_triggered_in_snippet_sources",
+        fs,
+        console,
+        result,
+    ));
+}
+
+#[test]
+fn no_unused_imports_is_not_triggered_in_snippet_sources() {
+    let fs = MemoryFileSystem::default();
+    let mut console = BufferConsole::default();
+
+    fs.insert(
+        "biome.json".into(),
+        r#"{ "html": { "linter": {"enabled": true}, "experimentalFullSupportEnabled": true } }"#
+            .as_bytes(),
+    );
+
+    let file = Utf8Path::new("file.svelte");
+    fs.insert(
+        file.into(),
+        r#"<script>
+import Component from "./Component.vue"
+</script>
+
+<Component />
+"#
+        .as_bytes(),
+    );
+
+    let (fs, result) = run_cli(
+        fs,
+        &mut console,
+        Args::from(["lint", "--only=noUnusedImports", file.as_str()].as_slice()),
+    );
+
+    assert!(result.is_ok(), "run_cli returned {result:?}");
+
+    assert_cli_snapshot(SnapshotPayload::new(
+        module_path!(),
+        "no_unused_imports_is_not_triggered_in_snippet_sources",
+        fs,
+        console,
+        result,
+    ));
+}
+
+const SVELTE_ENUM_IN_TEMPLATE: &str = r#"<script lang="ts">
+import { Component, FooEnum } from './types';
+</script>
+<main>
+  <Component />
+  {FooEnum.Foo}
+</main>"#;
+
+#[test]
+fn use_import_type_not_triggered_for_enum_in_template() {
+    let fs = MemoryFileSystem::default();
+    let mut console = BufferConsole::default();
+
+    let file = Utf8Path::new("file.svelte");
+    fs.insert(file.into(), SVELTE_ENUM_IN_TEMPLATE.as_bytes());
+
+    let (fs, result) = run_cli(
+        fs,
+        &mut console,
+        Args::from(["lint", "--only=useImportType", file.as_str()].as_slice()),
+    );
+
+    assert!(result.is_ok(), "run_cli returned {result:?}");
+
+    assert_cli_snapshot(SnapshotPayload::new(
+        module_path!(),
+        "use_import_type_not_triggered_for_enum_in_template",
+        fs,
+        console,
+        result,
+    ));
+}
+
+#[test]
+fn use_import_type_not_triggered_for_enum_in_template_v2() {
+    let fs = MemoryFileSystem::default();
+    let mut console = BufferConsole::default();
+
+    fs.insert(
+        "biome.json".into(),
+        r#"{ "html": { "linter": {"enabled": true}, "experimentalFullSupportEnabled": true } }"#
+            .as_bytes(),
+    );
+
+    let file = Utf8Path::new("file.svelte");
+    fs.insert(
+        file.into(),
+        r#"<script lang="ts">
+import { Avatar as AvatarPrimitive } from "bits-ui"; // <-- false positive
+import { cn } from "$lib/utils.js";
+
+let {
+	ref = $bindable(null),
+	class: className,
+}: AvatarPrimitive.FallbackProps = $props();
+</script>
+
+<!-- used as value here -->
+<AvatarPrimitive.Fallback
+	bind:ref
+	class="something nice"
+/>
+"#
+        .as_bytes(),
+    );
+
+    let (fs, result) = run_cli(
+        fs,
+        &mut console,
+        Args::from(["lint", "--only=useImportType", file.as_str()].as_slice()),
+    );
+
+    assert!(result.is_ok(), "run_cli returned {result:?}");
+
+    assert_cli_snapshot(SnapshotPayload::new(
+        module_path!(),
+        "use_import_type_not_triggered_for_enum_in_template_v2",
+        fs,
+        console,
+        result,
+    ));
+}
+#[test]
+fn no_useless_lone_block_statements_is_not_triggered() {
+    let fs = MemoryFileSystem::default();
+    let mut console = BufferConsole::default();
+
+    fs.insert(
+        "biome.json".into(),
+        r#"{ "html": { "linter": {"enabled": true}, "experimentalFullSupportEnabled": true } }"#
+            .as_bytes(),
+    );
+
+    let file = Utf8Path::new("file.svelte");
+    fs.insert(
+        file.into(),
+        r#"<CollapsiblePrimitive.Content>
+	{#snippet child({ props, open })}
+		{#if open}
+			<div {...props} transition:slide={{ duration }}>
+				{@render children?.()}
+			</div>
+		{/if}
+	{/snippet}
+</CollapsiblePrimitive.Content>
+"#
+        .as_bytes(),
+    );
+
+    let (fs, result) = run_cli(
+        fs,
+        &mut console,
+        Args::from(["lint", "--only=noUselessLoneBlockStatements", file.as_str()].as_slice()),
+    );
+
+    assert!(result.is_ok(), "run_cli returned {result:?}");
+
+    assert_cli_snapshot(SnapshotPayload::new(
+        module_path!(),
+        "no_useless_lone_block_statements_is_not_triggered",
+        fs,
+        console,
+        result,
+    ));
+}
+
+#[test]
+fn supports_ts_in_embedded_expressions() {
+    let fs = MemoryFileSystem::default();
+    let mut console = BufferConsole::default();
+
+    fs.insert(
+        "biome.json".into(),
+        r#"{ "html": { "linter": {"enabled": true}, "experimentalFullSupportEnabled": true } }"#
+            .as_bytes(),
+    );
+
+    let file = Utf8Path::new("file.svelte");
+    fs.insert(
+        file.into(),
+        r#"<script lang="ts">
+// this makes it typescript
+</script>
+
+<div
+	onclick={(e) => {
+		if ((e.target as HTMLElement).closest("button")) {
+			return;
+		}
+		e.currentTarget.parentElement?.querySelector("input")?.focus();
+	}}
+>
+</div>
+"#
+        .as_bytes(),
+    );
+
+    let (fs, result) = run_cli(
+        fs,
+        &mut console,
+        Args::from(["lint", "--only=noUselessLoneBlockStatements", file.as_str()].as_slice()),
+    );
+
+    assert!(result.is_ok(), "run_cli returned {result:?}");
+
+    assert_cli_snapshot(SnapshotPayload::new(
+        module_path!(),
+        "supports_ts_in_embedded_expressions",
+        fs,
+        console,
+        result,
+    ));
+}
+
+#[test]
+fn no_unused_variables_in_svelte_directives() {
+    let fs = MemoryFileSystem::default();
+    let mut console = BufferConsole::default();
+
+    fs.insert(
+        "biome.json".into(),
+        r#"{ "html": { "linter": {"enabled": true}, "experimentalFullSupportEnabled": true } }"#
+            .as_bytes(),
+    );
+
+    let file = Utf8Path::new("file.svelte");
+    fs.insert(
+        file.into(),
+        r#"<script>
+const isActive = false;
+const color = "red";
+let inputValue = "";
+let isChecked = false;
+</script>
+
+<main>
+  <!-- bind: directive -->
+  <input bind:value={inputValue} />
+
+  <!-- bind: directive with checkbox -->
+  <input type="checkbox" bind:checked={isChecked} />
+
+  <!-- class: directive -->
+  <div class:active={isActive}>Active</div>
+
+  <!-- style: directive -->
+  <div style:color={color}>Styled</div>
+
+  <!-- Using variables in text expressions -->
+  <p>{inputValue}</p>
+  <p>{isChecked}</p>
+</main>
+"#
+        .as_bytes(),
+    );
+
+    let (fs, result) = run_cli(
+        fs,
+        &mut console,
+        Args::from(["lint", "--only=noUnusedVariables", file.as_str()].as_slice()),
+    );
+
+    assert!(result.is_ok(), "run_cli returned {result:?}");
+
+    assert_cli_snapshot(SnapshotPayload::new(
+        module_path!(),
+        "no_unused_variables_in_svelte_directives",
+        fs,
+        console,
+        result,
+    ));
+}
+
+#[test]
+fn no_comma_operator_triggered_in_svelte_template_expression() {
+    let fs = MemoryFileSystem::default();
+    let mut console = BufferConsole::default();
+
+    fs.insert(
+        "biome.json".into(),
+        r#"{ "html": { "linter": {"enabled": true}, "experimentalFullSupportEnabled": true } }"#
+            .as_bytes(),
+    );
+
+    let file = Utf8Path::new("file.svelte");
+    fs.insert(
+        file.into(),
+        r#"<script>
+  let x = 1;
+</script>
+
+<!-- Comma operator in template expression - should be flagged -->
+<p>{(console.log("side effect"), x)}</p>"#
+            .as_bytes(),
+    );
+
+    let (fs, result) = run_cli(
+        fs,
+        &mut console,
+        Args::from(["lint", "--only=noCommaOperator", file.as_str()].as_slice()),
+    );
+
+    // The comma operator SHOULD be flagged in Svelte (hack only applies to Vue)
+    // Result is Ok because it's a warning, but console should contain the diagnostic
+    assert!(result.is_ok(), "run_cli returned {result:?}");
+    let has_comma_operator = console.out_buffer.iter().any(|m| {
+        let content = format!("{:?}", m.content);
+        content.contains("noCommaOperator")
+    });
+    assert!(
+        has_comma_operator,
+        "Expected noCommaOperator diagnostic in console output"
+    );
+
+    assert_cli_snapshot(SnapshotPayload::new(
+        module_path!(),
+        "no_comma_operator_triggered_in_svelte_template_expression",
+        fs,
+        console,
+        result,
+    ));
+}
+
+#[test]
+fn use_import_type_not_triggered_for_enum_in_control_flow_blocks() {
+    let fs = MemoryFileSystem::default();
+    let mut console = BufferConsole::default();
+
+    fs.insert(
+        "biome.json".into(),
+        r#"{ "html": { "linter": {"enabled": true}, "experimentalFullSupportEnabled": true } }"#
+            .as_bytes(),
+    );
+
+    let file = Utf8Path::new("file.svelte");
+    // the code in this file is intentionally ridiculous and doesn't necessarily make sense, but it covers a lot of different control flow blocks in one test
+    fs.insert(
+        file.into(),
+        r#"<script lang="ts">
+  import { IfEnum, ElseIfEnum, EachEnum, EachKeyEnum, KeyEnum, AwaitEnum } from './models.ts';
+
+  interface Props {
+    foo: IfEnum;
+    bar: ElseIfEnum;
+    baz: EachEnum;
+    bap: EachKeyEnum;
+    qux: KeyEnum;
+    zap: AwaitEnum;
+  }
+  let { foo }: Props = $props();
+</script>
+
+{#if foo === IfEnum.private}
+  private
+{:else if foo === ElseIfEnum.public}
+  public
+{/if}
+
+{#each EachEnum.Foo as item (EachKeyEnum[item])}
+  {item.name}
+{/each}
+
+{#key KeyEnum.Foo}
+  <Component />
+{/key}
+
+{#await AwaitEnum.Foo}
+  loading
+{:then data}
+  {data}
+{/await}
+"#
+        .as_bytes(),
+    );
+
+    let (fs, result) = run_cli(
+        fs,
+        &mut console,
+        Args::from(["lint", "--only=useImportType", file.as_str()].as_slice()),
+    );
+
+    assert!(result.is_ok(), "run_cli returned {result:?}");
+
+    assert_cli_snapshot(SnapshotPayload::new(
+        module_path!(),
+        "use_import_type_not_triggered_for_enum_in_control_flow_blocks",
+        fs,
+        console,
+        result,
+    ));
+}
diff --git a/crates/biome_cli/tests/snapshots/main_cases_handle_svelte_files/no_undeclared_variables_check_types_handles_svelte_ts_script_globals.snap b/crates/biome_cli/tests/snapshots/main_cases_handle_svelte_files/no_undeclared_variables_check_types_handles_svelte_ts_script_globals.snap
new file mode 100644
index 000000000000..854a15a1ac29
--- /dev/null
+++ b/crates/biome_cli/tests/snapshots/main_cases_handle_svelte_files/no_undeclared_variables_check_types_handles_svelte_ts_script_globals.snap
@@ -0,0 +1,37 @@
+---
+source: crates/biome_cli/tests/snap_test.rs
+expression: redactor(content)
+---
+## `biome.json`
+
+```json
+{
+  "linter": {
+    "rules": {
+      "correctness": {
+        "noUndeclaredVariables": {
+          "level": "error",
+          "options": {
+            "checkTypes": true
+          }
+        }
+      }
+    }
+  }
+}
+```
+
+## `file.svelte`
+
+```svelte
+<script lang="ts">
+type B<T> = PromiseLike<T>;
+</script>
+<div></div>
+```
+
+# Emitted Messages
+
+```block
+Checked 1 file in <TIME>. No fixes applied.
+```
diff --git a/crates/biome_cli/tests/snapshots/main_cases_handle_svelte_files/no_undeclared_variables_handles_svelte_js_module_store_dereference.snap b/crates/biome_cli/tests/snapshots/main_cases_handle_svelte_files/no_undeclared_variables_handles_svelte_js_module_store_dereference.snap
new file mode 100644
index 000000000000..6fa0a04506d4
--- /dev/null
+++ b/crates/biome_cli/tests/snapshots/main_cases_handle_svelte_files/no_undeclared_variables_handles_svelte_js_module_store_dereference.snap
@@ -0,0 +1,47 @@
+---
+source: crates/biome_cli/tests/snap_test.rs
+assertion_line: 520
+expression: redactor(content)
+---
+## `file.svelte.js`
+
+```js
+import { writable } from "svelte/store";
+const count = writable(1);
+$count;
+$missing;
+```
+
+# Termination Message
+
+```block
+lint ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  × Some errors were emitted while running checks.
+  
+
+
+```
+
+# Emitted Messages
+
+```block
+file.svelte.js:4:1 lint/correctness/noUndeclaredVariables ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  × The $missing variable is undeclared.
+  
+    2 │ const count = writable(1);
+    3 │ $count;
+  > 4 │ $missing;
+      │ ^^^^^^^^
+  
+  i By default, Biome recognizes browser and Node.js globals.
+    You can ignore more globals using the javascript.globals configuration.
+  
+
+```
+
+```block
+Checked 1 file in <TIME>. No fixes applied.
+Found 1 error.
+```
diff --git a/crates/biome_cli/tests/snapshots/main_cases_handle_svelte_files/no_undeclared_variables_handles_svelte_module_store_dereference.snap b/crates/biome_cli/tests/snapshots/main_cases_handle_svelte_files/no_undeclared_variables_handles_svelte_module_store_dereference.snap
new file mode 100644
index 000000000000..680b498769e8
--- /dev/null
+++ b/crates/biome_cli/tests/snapshots/main_cases_handle_svelte_files/no_undeclared_variables_handles_svelte_module_store_dereference.snap
@@ -0,0 +1,47 @@
+---
+source: crates/biome_cli/tests/snap_test.rs
+assertion_line: 520
+expression: redactor(content)
+---
+## `file.svelte.ts`
+
+```ts
+import { writable } from "svelte/store";
+const count = writable(1);
+$count;
+$missing;
+```
+
+# Termination Message
+
+```block
+lint ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  × Some errors were emitted while running checks.
+  
+
+
+```
+
+# Emitted Messages
+
+```block
+file.svelte.ts:4:1 lint/correctness/noUndeclaredVariables ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  × The $missing variable is undeclared.
+  
+    2 │ const count = writable(1);
+    3 │ $count;
+  > 4 │ $missing;
+      │ ^^^^^^^^
+  
+  i By default, Biome recognizes browser and Node.js globals.
+    You can ignore more globals using the javascript.globals configuration.
+  
+
+```
+
+```block
+Checked 1 file in <TIME>. No fixes applied.
+Found 1 error.
+```
diff --git a/crates/biome_cli/tests/snapshots/main_cases_handle_svelte_files/no_undeclared_variables_handles_svelte_module_type_only_store_dereference.snap b/crates/biome_cli/tests/snapshots/main_cases_handle_svelte_files/no_undeclared_variables_handles_svelte_module_type_only_store_dereference.snap
new file mode 100644
index 000000000000..b61e0a85e27a
--- /dev/null
+++ b/crates/biome_cli/tests/snapshots/main_cases_handle_svelte_files/no_undeclared_variables_handles_svelte_module_type_only_store_dereference.snap
@@ -0,0 +1,44 @@
+---
+source: crates/biome_cli/tests/snap_test.rs
+assertion_line: 520
+expression: redactor(content)
+---
+## `file.svelte.ts`
+
+```ts
+type count = number;
+$count;
+```
+
+# Termination Message
+
+```block
+lint ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  × Some errors were emitted while running checks.
+  
+
+
+```
+
+# Emitted Messages
+
+```block
+file.svelte.ts:2:1 lint/correctness/noUndeclaredVariables ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  × The $count variable is undeclared.
+  
+    1 │ type count = number;
+  > 2 │ $count;
+      │ ^^^^^^
+  
+  i By default, Biome recognizes browser and Node.js globals.
+    You can ignore more globals using the javascript.globals configuration.
+  
+
+```
+
+```block
+Checked 1 file in <TIME>. No fixes applied.
+Found 1 error.
+```
diff --git a/crates/biome_cli/tests/snapshots/main_cases_handle_svelte_files/no_undeclared_variables_handles_svelte_store_dereference.snap b/crates/biome_cli/tests/snapshots/main_cases_handle_svelte_files/no_undeclared_variables_handles_svelte_store_dereference.snap
new file mode 100644
index 000000000000..af11ef2743de
--- /dev/null
+++ b/crates/biome_cli/tests/snapshots/main_cases_handle_svelte_files/no_undeclared_variables_handles_svelte_store_dereference.snap
@@ -0,0 +1,52 @@
+---
+source: crates/biome_cli/tests/snap_test.rs
+assertion_line: 520
+expression: redactor(content)
+---
+## `file.svelte`
+
+```svelte
+<script>
+import { writable } from "svelte/store";
+const count = writable(1);
+$count;
+$missing;
+</script>
+<div></div>
+```
+
+# Termination Message
+
+```block
+lint ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  × Some errors were emitted while running checks.
+  
+
+
+```
+
+# Emitted Messages
+
+```block
+file.svelte:5:1 lint/correctness/noUndeclaredVariables ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  × The $missing variable is undeclared.
+  
+    3 │ const count = writable(1);
+    4 │ $count;
+  > 5 │ $missing;
+      │ ^^^^^^^^
+    6 │ </script>
+    7 │ <div></div>
+  
+  i By default, Biome recognizes browser and Node.js globals.
+    You can ignore more globals using the javascript.globals configuration.
+  
+
+```
+
+```block
+Checked 1 file in <TIME>. No fixes applied.
+Found 1 error.
+```
diff --git a/crates/biome_js_analyze/src/lint/correctness/no_undeclared_variables.rs b/crates/biome_js_analyze/src/lint/correctness/no_undeclared_variables.rs
index f83f9f1ee903..8207664e1880 100644
--- a/crates/biome_js_analyze/src/lint/correctness/no_undeclared_variables.rs
+++ b/crates/biome_js_analyze/src/lint/correctness/no_undeclared_variables.rs
@@ -69,7 +69,14 @@ impl Rule for NoUndeclaredVariables {
     type Options = NoUndeclaredVariablesOptions;
 
     fn run(ctx: &RuleContext<Self>) -> Self::Signals {
-        ctx.query()
+        let model = ctx.query();
+        let source_type = ctx.source_type::<JsFileSource>();
+        let embedded_bindings = ctx
+            .get_service::<EmbeddedBindings>()
+            .expect("embedded bindings service");
+        let flavor = model.flavor();
+
+        model
             .all_unresolved_references()
             .filter_map(|reference| {
                 let identifier = reference.tree();
@@ -80,17 +87,19 @@ impl Rule for NoUndeclaredVariables {
 
                 let token = identifier.value_token().ok()?;
                 let text = token.text_trimmed();
+                // Semantic resolution handles declared `$store` bindings; this fallback keeps
+                // configured globals and embedded bindings aligned on `store`.
+                let store_name = flavor.store_reference_name(text);
 
-                let source_type = ctx.source_type::<JsFileSource>();
-
-                if ctx.is_global(text) {
+                if ctx.is_global(text) || store_name.is_some_and(|store_name| ctx.is_global(store_name))
+                {
                     return None;
                 }
 
-                let embedded_bindings = ctx
-                    .get_service::<EmbeddedBindings>()
-                    .expect("embedded bindings service");
-                if embedded_bindings.contains_binding(text) {
+                if embedded_bindings.contains_binding(text)
+                    || store_name
+                        .is_some_and(|store_name| embedded_bindings.contains_binding(store_name))
+                {
                     return None;
                 }
 
diff --git a/crates/biome_js_analyze/src/services/semantic.rs b/crates/biome_js_analyze/src/services/semantic.rs
index 3de96c209825..16b3a3772982 100644
--- a/crates/biome_js_analyze/src/services/semantic.rs
+++ b/crates/biome_js_analyze/src/services/semantic.rs
@@ -4,7 +4,7 @@ use biome_analyze::{
     VisitorFinishContext,
 };
 use biome_js_semantic::{SemanticEventExtractor, SemanticModel, SemanticModelBuilder};
-use biome_js_syntax::{AnyJsRoot, JsLanguage, JsSyntaxNode, TextRange, WalkEvent};
+use biome_js_syntax::{AnyJsRoot, JsFileSource, JsLanguage, JsSyntaxNode, TextRange, WalkEvent};
 use biome_rowan::AstNode;
 
 pub struct SemanticServices {
@@ -88,6 +88,10 @@ where
         N::unwrap_cast(node.clone())
     }
 }
+/// Syntax-phase visitor that extracts semantic events and builds semantic data.
+///
+/// Flavor-specific behavior (for example Svelte semantics) is configured from
+/// the file source service when entering the root node.
 pub struct SemanticModelBuilderVisitor {
     extractor: SemanticEventExtractor,
     builder: SemanticModelBuilder,
@@ -105,7 +109,22 @@ impl SemanticModelBuilderVisitor {
 impl Visitor for SemanticModelBuilderVisitor {
     type Language = JsLanguage;
 
-    fn visit(&mut self, event: &WalkEvent<JsSyntaxNode>, _ctx: VisitorContext<JsLanguage>) {
+    fn visit(&mut self, event: &WalkEvent<JsSyntaxNode>, ctx: VisitorContext<JsLanguage>) {
+        // Visitor construction has no access to the service bag, so configure
+        // semantic flavor when we enter the root node.
+        if let WalkEvent::Enter(node) = event
+            && node.parent().is_none()
+        {
+            let source_type = ctx
+                .services
+                .get_service::<JsFileSource>()
+                .copied()
+                .unwrap_or_default();
+            let flavor = (&source_type).into();
+            self.extractor.set_flavor(flavor);
+            self.builder.set_flavor(flavor);
+        }
+
         match event {
             WalkEvent::Enter(node) => {
                 self.builder.push_node(node);
diff --git a/crates/biome_js_analyze/tests/spec_tests.rs b/crates/biome_js_analyze/tests/spec_tests.rs
index 053eb8b5c206..3f80db28d7fd 100644
--- a/crates/biome_js_analyze/tests/spec_tests.rs
+++ b/crates/biome_js_analyze/tests/spec_tests.rs
@@ -209,7 +209,7 @@ pub(crate) fn analyze_and_snap(
     } else {
         Default::default()
     };
-    let semantic_model = semantic_model(&root, SemanticModelOptions::default());
+    let semantic_model = semantic_model(&root, SemanticModelOptions::from(&source_type));
 
     let services = JsAnalyzerServices::from((
         module_graph,
diff --git a/crates/biome_js_analyze/tests/specs/correctness/noConstAssign/validSvelteStoreWrite.svelte.ts b/crates/biome_js_analyze/tests/specs/correctness/noConstAssign/validSvelteStoreWrite.svelte.ts
new file mode 100644
index 000000000000..0f741c4fed66
--- /dev/null
+++ b/crates/biome_js_analyze/tests/specs/correctness/noConstAssign/validSvelteStoreWrite.svelte.ts
@@ -0,0 +1,4 @@
+// should not generate diagnostics
+import { writable } from "svelte/store";
+const store = writable(0);
+$store = 1;
diff --git a/crates/biome_js_analyze/tests/specs/correctness/noConstAssign/validSvelteStoreWrite.svelte.ts.snap b/crates/biome_js_analyze/tests/specs/correctness/noConstAssign/validSvelteStoreWrite.svelte.ts.snap
new file mode 100644
index 000000000000..f59ce68f9007
--- /dev/null
+++ b/crates/biome_js_analyze/tests/specs/correctness/noConstAssign/validSvelteStoreWrite.svelte.ts.snap
@@ -0,0 +1,12 @@
+---
+source: crates/biome_js_analyze/tests/spec_tests.rs
+expression: validSvelteStoreWrite.svelte.ts
+---
+# Input
+```ts
+// should not generate diagnostics
+import { writable } from "svelte/store";
+const store = writable(0);
+$store = 1;
+
+```
diff --git a/crates/biome_js_analyze/tests/specs/correctness/noUndeclaredVariables/invalid.svelte.ts b/crates/biome_js_analyze/tests/specs/correctness/noUndeclaredVariables/invalid.svelte.ts
index d6f764c330b7..ecab1b71698b 100644
--- a/crates/biome_js_analyze/tests/specs/correctness/noUndeclaredVariables/invalid.svelte.ts
+++ b/crates/biome_js_analyze/tests/specs/correctness/noUndeclaredVariables/invalid.svelte.ts
@@ -1,3 +1,4 @@
+/* should generate diagnostics */
 class Todo {
     done = $unknown(false);
     text = $unknown();
@@ -5,4 +6,4 @@ class Todo {
     constructor(text) {
         this.text = text;
     }
-}
\ No newline at end of file
+}
diff --git a/crates/biome_js_analyze/tests/specs/correctness/noUndeclaredVariables/invalid.svelte.ts.snap b/crates/biome_js_analyze/tests/specs/correctness/noUndeclaredVariables/invalid.svelte.ts.snap
index 092dac8d2f56..641be47284c2 100644
--- a/crates/biome_js_analyze/tests/specs/correctness/noUndeclaredVariables/invalid.svelte.ts.snap
+++ b/crates/biome_js_analyze/tests/specs/correctness/noUndeclaredVariables/invalid.svelte.ts.snap
@@ -1,9 +1,11 @@
 ---
 source: crates/biome_js_analyze/tests/spec_tests.rs
+assertion_line: 154
 expression: invalid.svelte.ts
 ---
 # Input
 ```ts
+/* should generate diagnostics */
 class Todo {
     done = $unknown(false);
     text = $unknown();
@@ -12,19 +14,21 @@ class Todo {
         this.text = text;
     }
 }
+
 ```
 
 # Diagnostics
 ```
-invalid.svelte.ts:2:12 lint/correctness/noUndeclaredVariables ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+invalid.svelte.ts:3:12 lint/correctness/noUndeclaredVariables ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
   × The $unknown variable is undeclared.
   
-    1 │ class Todo {
-  > 2 │     done = $unknown(false);
+    1 │ /* should generate diagnostics */
+    2 │ class Todo {
+  > 3 │     done = $unknown(false);
       │            ^^^^^^^^
-    3 │     text = $unknown();
-    4 │ 
+    4 │     text = $unknown();
+    5 │ 
   
   i By default, Biome recognizes browser and Node.js globals.
     You can ignore more globals using the javascript.globals configuration.
@@ -33,16 +37,16 @@ invalid.svelte.ts:2:12 lint/correctness/noUndeclaredVariables ━━━━━━
 ```
 
 ```
-invalid.svelte.ts:3:12 lint/correctness/noUndeclaredVariables ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+invalid.svelte.ts:4:12 lint/correctness/noUndeclaredVariables ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
   × The $unknown variable is undeclared.
   
-    1 │ class Todo {
-    2 │     done = $unknown(false);
-  > 3 │     text = $unknown();
+    2 │ class Todo {
+    3 │     done = $unknown(false);
+  > 4 │     text = $unknown();
       │            ^^^^^^^^
-    4 │ 
-    5 │     constructor(text) {
+    5 │ 
+    6 │     constructor(text) {
   
   i By default, Biome recognizes browser and Node.js globals.
     You can ignore more globals using the javascript.globals configuration.
diff --git a/crates/biome_js_analyze/tests/specs/correctness/noUndeclaredVariables/invalidBuiltinGlobalStoreDereference.svelte.ts b/crates/biome_js_analyze/tests/specs/correctness/noUndeclaredVariables/invalidBuiltinGlobalStoreDereference.svelte.ts
new file mode 100644
index 000000000000..80e5a4eb0238
--- /dev/null
+++ b/crates/biome_js_analyze/tests/specs/correctness/noUndeclaredVariables/invalidBuiltinGlobalStoreDereference.svelte.ts
@@ -0,0 +1,2 @@
+/* should generate diagnostics */
+$location;
diff --git a/crates/biome_js_analyze/tests/specs/correctness/noUndeclaredVariables/invalidBuiltinGlobalStoreDereference.svelte.ts.snap b/crates/biome_js_analyze/tests/specs/correctness/noUndeclaredVariables/invalidBuiltinGlobalStoreDereference.svelte.ts.snap
new file mode 100644
index 000000000000..fab3a8d0c39d
--- /dev/null
+++ b/crates/biome_js_analyze/tests/specs/correctness/noUndeclaredVariables/invalidBuiltinGlobalStoreDereference.svelte.ts.snap
@@ -0,0 +1,28 @@
+---
+source: crates/biome_js_analyze/tests/spec_tests.rs
+assertion_line: 154
+expression: invalidBuiltinGlobalStoreDereference.svelte.ts
+---
+# Input
+```ts
+/* should generate diagnostics */
+$location;
+
+```
+
+# Diagnostics
+```
+invalidBuiltinGlobalStoreDereference.svelte.ts:2:1 lint/correctness/noUndeclaredVariables ━━━━━━━━━━
+
+  × The $location variable is undeclared.
+  
+    1 │ /* should generate diagnostics */
+  > 2 │ $location;
+      │ ^^^^^^^^^
+    3 │ 
+  
+  i By default, Biome recognizes browser and Node.js globals.
+    You can ignore more globals using the javascript.globals configuration.
+  
+
+```
diff --git a/crates/biome_js_analyze/tests/specs/correctness/noUndeclaredVariables/invalidDollarPrefixedConfiguredGlobal.js b/crates/biome_js_analyze/tests/specs/correctness/noUndeclaredVariables/invalidDollarPrefixedConfiguredGlobal.js
new file mode 100644
index 000000000000..1cd424585954
--- /dev/null
+++ b/crates/biome_js_analyze/tests/specs/correctness/noUndeclaredVariables/invalidDollarPrefixedConfiguredGlobal.js
@@ -0,0 +1 @@
+$foo;
diff --git a/crates/biome_js_analyze/tests/specs/correctness/noUndeclaredVariables/invalidDollarPrefixedConfiguredGlobal.js.snap b/crates/biome_js_analyze/tests/specs/correctness/noUndeclaredVariables/invalidDollarPrefixedConfiguredGlobal.js.snap
new file mode 100644
index 000000000000..1bcd918ead8c
--- /dev/null
+++ b/crates/biome_js_analyze/tests/specs/correctness/noUndeclaredVariables/invalidDollarPrefixedConfiguredGlobal.js.snap
@@ -0,0 +1,25 @@
+---
+source: crates/biome_js_analyze/tests/spec_tests.rs
+expression: invalidDollarPrefixedConfiguredGlobal.js
+---
+# Input
+```js
+$foo;
+
+```
+
+# Diagnostics
+```
+invalidDollarPrefixedConfiguredGlobal.js:1:1 lint/correctness/noUndeclaredVariables ━━━━━━━━━━━━━━━━
+
+  × The $foo variable is undeclared.
+  
+  > 1 │ $foo;
+      │ ^^^^
+    2 │ 
+  
+  i By default, Biome recognizes browser and Node.js globals.
+    You can ignore more globals using the javascript.globals configuration.
+  
+
+```
diff --git a/crates/biome_js_analyze/tests/specs/correctness/noUndeclaredVariables/invalidDollarPrefixedConfiguredGlobal.options.json b/crates/biome_js_analyze/tests/specs/correctness/noUndeclaredVariables/invalidDollarPrefixedConfiguredGlobal.options.json
new file mode 100644
index 000000000000..00fd10dd724f
--- /dev/null
+++ b/crates/biome_js_analyze/tests/specs/correctness/noUndeclaredVariables/invalidDollarPrefixedConfiguredGlobal.options.json
@@ -0,0 +1,5 @@
+{
+  "javascript": {
+    "globals": ["foo"]
+  }
+}
diff --git a/crates/biome_js_analyze/tests/specs/correctness/noUndeclaredVariables/invalidDoubleDollarStoreDereference.svelte.ts b/crates/biome_js_analyze/tests/specs/correctness/noUndeclaredVariables/invalidDoubleDollarStoreDereference.svelte.ts
new file mode 100644
index 000000000000..fc2caa2e4e9a
--- /dev/null
+++ b/crates/biome_js_analyze/tests/specs/correctness/noUndeclaredVariables/invalidDoubleDollarStoreDereference.svelte.ts
@@ -0,0 +1,2 @@
+/* should generate diagnostics */
+$$state;
diff --git a/crates/biome_js_analyze/tests/specs/correctness/noUndeclaredVariables/invalidDoubleDollarStoreDereference.svelte.ts.snap b/crates/biome_js_analyze/tests/specs/correctness/noUndeclaredVariables/invalidDoubleDollarStoreDereference.svelte.ts.snap
new file mode 100644
index 000000000000..e1379df6d52b
--- /dev/null
+++ b/crates/biome_js_analyze/tests/specs/correctness/noUndeclaredVariables/invalidDoubleDollarStoreDereference.svelte.ts.snap
@@ -0,0 +1,28 @@
+---
+source: crates/biome_js_analyze/tests/spec_tests.rs
+assertion_line: 154
+expression: invalidDoubleDollarStoreDereference.svelte.ts
+---
+# Input
+```ts
+/* should generate diagnostics */
+$$state;
+
+```
+
+# Diagnostics
+```
+invalidDoubleDollarStoreDereference.svelte.ts:2:1 lint/correctness/noUndeclaredVariables ━━━━━━━━━━━
+
+  × The $$state variable is undeclared.
+  
+    1 │ /* should generate diagnostics */
+  > 2 │ $$state;
+      │ ^^^^^^^
+    3 │ 
+  
+  i By default, Biome recognizes browser and Node.js globals.
+    You can ignore more globals using the javascript.globals configuration.
+  
+
+```
diff --git a/crates/biome_js_analyze/tests/specs/correctness/noUndeclaredVariables/invalidStoreDereference.ts b/crates/biome_js_analyze/tests/specs/correctness/noUndeclaredVariables/invalidStoreDereference.ts
new file mode 100644
index 000000000000..0c64d1b7860c
--- /dev/null
+++ b/crates/biome_js_analyze/tests/specs/correctness/noUndeclaredVariables/invalidStoreDereference.ts
@@ -0,0 +1,3 @@
+/* should generate diagnostics */
+const store = 1;
+$store;
diff --git a/crates/biome_js_analyze/tests/specs/correctness/noUndeclaredVariables/invalidStoreDereference.ts.snap b/crates/biome_js_analyze/tests/specs/correctness/noUndeclaredVariables/invalidStoreDereference.ts.snap
new file mode 100644
index 000000000000..1a3aa3b15add
--- /dev/null
+++ b/crates/biome_js_analyze/tests/specs/correctness/noUndeclaredVariables/invalidStoreDereference.ts.snap
@@ -0,0 +1,30 @@
+---
+source: crates/biome_js_analyze/tests/spec_tests.rs
+assertion_line: 154
+expression: invalidStoreDereference.ts
+---
+# Input
+```ts
+/* should generate diagnostics */
+const store = 1;
+$store;
+
+```
+
+# Diagnostics
+```
+invalidStoreDereference.ts:3:1 lint/correctness/noUndeclaredVariables ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  × The $store variable is undeclared.
+  
+    1 │ /* should generate diagnostics */
+    2 │ const store = 1;
+  > 3 │ $store;
+      │ ^^^^^^
+    4 │ 
+  
+  i By default, Biome recognizes browser and Node.js globals.
+    You can ignore more globals using the javascript.globals configuration.
+  
+
+```
diff --git a/crates/biome_js_analyze/tests/specs/correctness/noUndeclaredVariables/invalidTypeOnlyStoreDereference.svelte.ts b/crates/biome_js_analyze/tests/specs/correctness/noUndeclaredVariables/invalidTypeOnlyStoreDereference.svelte.ts
new file mode 100644
index 000000000000..25349e5ca8bc
--- /dev/null
+++ b/crates/biome_js_analyze/tests/specs/correctness/noUndeclaredVariables/invalidTypeOnlyStoreDereference.svelte.ts
@@ -0,0 +1,3 @@
+/* should generate diagnostics */
+type store = number;
+$store;
diff --git a/crates/biome_js_analyze/tests/specs/correctness/noUndeclaredVariables/invalidTypeOnlyStoreDereference.svelte.ts.snap b/crates/biome_js_analyze/tests/specs/correctness/noUndeclaredVariables/invalidTypeOnlyStoreDereference.svelte.ts.snap
new file mode 100644
index 000000000000..89defe61b51a
--- /dev/null
+++ b/crates/biome_js_analyze/tests/specs/correctness/noUndeclaredVariables/invalidTypeOnlyStoreDereference.svelte.ts.snap
@@ -0,0 +1,30 @@
+---
+source: crates/biome_js_analyze/tests/spec_tests.rs
+assertion_line: 154
+expression: invalidTypeOnlyStoreDereference.svelte.ts
+---
+# Input
+```ts
+/* should generate diagnostics */
+type store = number;
+$store;
+
+```
+
+# Diagnostics
+```
+invalidTypeOnlyStoreDereference.svelte.ts:3:1 lint/correctness/noUndeclaredVariables ━━━━━━━━━━━━━━━
+
+  × The $store variable is undeclared.
+  
+    1 │ /* should generate diagnostics */
+    2 │ type store = number;
+  > 3 │ $store;
+      │ ^^^^^^
+    4 │ 
+  
+  i By default, Biome recognizes browser and Node.js globals.
+    You can ignore more globals using the javascript.globals configuration.
+  
+
+```
diff --git a/crates/biome_js_analyze/tests/specs/correctness/noUndeclaredVariables/stores-invalid.svelte b/crates/biome_js_analyze/tests/specs/correctness/noUndeclaredVariables/stores-invalid.svelte
new file mode 100644
index 000000000000..0b9e75badfc9
--- /dev/null
+++ b/crates/biome_js_analyze/tests/specs/correctness/noUndeclaredVariables/stores-invalid.svelte
@@ -0,0 +1,4 @@
+<!-- should generate diagnostics -->
+<script>
+	$count;
+</script>
diff --git a/crates/biome_js_analyze/tests/specs/correctness/noUndeclaredVariables/stores-invalid.svelte.snap b/crates/biome_js_analyze/tests/specs/correctness/noUndeclaredVariables/stores-invalid.svelte.snap
new file mode 100644
index 000000000000..b87831812766
--- /dev/null
+++ b/crates/biome_js_analyze/tests/specs/correctness/noUndeclaredVariables/stores-invalid.svelte.snap
@@ -0,0 +1,31 @@
+---
+source: crates/biome_js_analyze/tests/spec_tests.rs
+expression: stores-invalid.svelte
+---
+# Input
+```svelte
+<!-- should generate diagnostics -->
+<script>
+	$count;
+</script>
+
+```
+
+# Diagnostics
+```
+stores-invalid.svelte:3:2 lint/correctness/noUndeclaredVariables ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  × The $count variable is undeclared.
+  
+    1 │ <!-- should generate diagnostics -->
+    2 │ <script>
+  > 3 │ 	$count;
+      │ 	^^^^^^
+    4 │ </script>
+    5 │ 
+  
+  i By default, Biome recognizes browser and Node.js globals.
+    You can ignore more globals using the javascript.globals configuration.
+  
+
+```
diff --git a/crates/biome_js_analyze/tests/specs/correctness/noUndeclaredVariables/stores-valid.svelte b/crates/biome_js_analyze/tests/specs/correctness/noUndeclaredVariables/stores-valid.svelte
new file mode 100644
index 000000000000..a180512bac75
--- /dev/null
+++ b/crates/biome_js_analyze/tests/specs/correctness/noUndeclaredVariables/stores-valid.svelte
@@ -0,0 +1,7 @@
+<!-- should not generate diagnostics -->
+<script>
+	import { writable } from "svelte/store";
+
+	const count = writable(1);
+	$count;
+</script>
diff --git a/crates/biome_js_analyze/tests/specs/correctness/noUndeclaredVariables/stores-valid.svelte.snap b/crates/biome_js_analyze/tests/specs/correctness/noUndeclaredVariables/stores-valid.svelte.snap
new file mode 100644
index 000000000000..dab42afe8694
--- /dev/null
+++ b/crates/biome_js_analyze/tests/specs/correctness/noUndeclaredVariables/stores-valid.svelte.snap
@@ -0,0 +1,15 @@
+---
+source: crates/biome_js_analyze/tests/spec_tests.rs
+expression: stores-valid.svelte
+---
+# Input
+```svelte
+<!-- should not generate diagnostics -->
+<script>
+	import { writable } from "svelte/store";
+
+	const count = writable(1);
+	$count;
+</script>
+
+```
diff --git a/crates/biome_js_analyze/tests/specs/correctness/noUndeclaredVariables/validDollarPrefixedIdentifier.svelte.ts b/crates/biome_js_analyze/tests/specs/correctness/noUndeclaredVariables/validDollarPrefixedIdentifier.svelte.ts
new file mode 100644
index 000000000000..d27c5ad39f53
--- /dev/null
+++ b/crates/biome_js_analyze/tests/specs/correctness/noUndeclaredVariables/validDollarPrefixedIdentifier.svelte.ts
@@ -0,0 +1,3 @@
+/* should not generate diagnostics */
+const $store = 1;
+$store;
diff --git a/crates/biome_js_analyze/tests/specs/correctness/noUndeclaredVariables/validDollarPrefixedIdentifier.svelte.ts.snap b/crates/biome_js_analyze/tests/specs/correctness/noUndeclaredVariables/validDollarPrefixedIdentifier.svelte.ts.snap
new file mode 100644
index 000000000000..4eb4fad9ebe6
--- /dev/null
+++ b/crates/biome_js_analyze/tests/specs/correctness/noUndeclaredVariables/validDollarPrefixedIdentifier.svelte.ts.snap
@@ -0,0 +1,11 @@
+---
+source: crates/biome_js_analyze/tests/spec_tests.rs
+expression: validDollarPrefixedIdentifier.svelte.ts
+---
+# Input
+```ts
+/* should not generate diagnostics */
+const $store = 1;
+$store;
+
+```
diff --git a/crates/biome_js_analyze/tests/specs/correctness/noUndeclaredVariables/validStoreDereference.svelte.ts b/crates/biome_js_analyze/tests/specs/correctness/noUndeclaredVariables/validStoreDereference.svelte.ts
new file mode 100644
index 000000000000..d40217ba6e1f
--- /dev/null
+++ b/crates/biome_js_analyze/tests/specs/correctness/noUndeclaredVariables/validStoreDereference.svelte.ts
@@ -0,0 +1,3 @@
+/* should not generate diagnostics */
+const store = 1;
+$store;
diff --git a/crates/biome_js_analyze/tests/specs/correctness/noUndeclaredVariables/validStoreDereference.svelte.ts.snap b/crates/biome_js_analyze/tests/specs/correctness/noUndeclaredVariables/validStoreDereference.svelte.ts.snap
new file mode 100644
index 000000000000..543bc00f6e6f
--- /dev/null
+++ b/crates/biome_js_analyze/tests/specs/correctness/noUndeclaredVariables/validStoreDereference.svelte.ts.snap
@@ -0,0 +1,11 @@
+---
+source: crates/biome_js_analyze/tests/spec_tests.rs
+expression: validStoreDereference.svelte.ts
+---
+# Input
+```ts
+/* should not generate diagnostics */
+const store = 1;
+$store;
+
+```
diff --git a/crates/biome_js_analyze/tests/specs/correctness/noUndeclaredVariables/validSvelteGlobalStoreDereference.svelte.options.json b/crates/biome_js_analyze/tests/specs/correctness/noUndeclaredVariables/validSvelteGlobalStoreDereference.svelte.options.json
new file mode 100644
index 000000000000..471b07bb790c
--- /dev/null
+++ b/crates/biome_js_analyze/tests/specs/correctness/noUndeclaredVariables/validSvelteGlobalStoreDereference.svelte.options.json
@@ -0,0 +1,5 @@
+{
+    "javascript": {
+        "globals": ["store"]
+    }
+}
diff --git a/crates/biome_js_analyze/tests/specs/correctness/noUndeclaredVariables/validSvelteGlobalStoreDereference.svelte.ts b/crates/biome_js_analyze/tests/specs/correctness/noUndeclaredVariables/validSvelteGlobalStoreDereference.svelte.ts
new file mode 100644
index 000000000000..bf5fcbac997f
--- /dev/null
+++ b/crates/biome_js_analyze/tests/specs/correctness/noUndeclaredVariables/validSvelteGlobalStoreDereference.svelte.ts
@@ -0,0 +1,2 @@
+/* should not generate diagnostics */
+$store;
diff --git a/crates/biome_js_analyze/tests/specs/correctness/noUndeclaredVariables/validSvelteGlobalStoreDereference.svelte.ts.snap b/crates/biome_js_analyze/tests/specs/correctness/noUndeclaredVariables/validSvelteGlobalStoreDereference.svelte.ts.snap
new file mode 100644
index 000000000000..725adcff3d56
--- /dev/null
+++ b/crates/biome_js_analyze/tests/specs/correctness/noUndeclaredVariables/validSvelteGlobalStoreDereference.svelte.ts.snap
@@ -0,0 +1,10 @@
+---
+source: crates/biome_js_analyze/tests/spec_tests.rs
+expression: validSvelteGlobalStoreDereference.svelte.ts
+---
+# Input
+```ts
+/* should not generate diagnostics */
+$store;
+
+```
diff --git a/crates/biome_js_analyze/tests/specs/suspicious/noImportAssign/validSvelteStoreWrite.svelte.ts b/crates/biome_js_analyze/tests/specs/suspicious/noImportAssign/validSvelteStoreWrite.svelte.ts
new file mode 100644
index 000000000000..714fc07f3e15
--- /dev/null
+++ b/crates/biome_js_analyze/tests/specs/suspicious/noImportAssign/validSvelteStoreWrite.svelte.ts
@@ -0,0 +1,3 @@
+// should not generate diagnostics
+import store from "./store";
+$store = 1;
diff --git a/crates/biome_js_analyze/tests/specs/suspicious/noImportAssign/validSvelteStoreWrite.svelte.ts.snap b/crates/biome_js_analyze/tests/specs/suspicious/noImportAssign/validSvelteStoreWrite.svelte.ts.snap
new file mode 100644
index 000000000000..2b9361788e6b
--- /dev/null
+++ b/crates/biome_js_analyze/tests/specs/suspicious/noImportAssign/validSvelteStoreWrite.svelte.ts.snap
@@ -0,0 +1,11 @@
+---
+source: crates/biome_js_analyze/tests/spec_tests.rs
+expression: validSvelteStoreWrite.svelte.ts
+---
+# Input
+```ts
+// should not generate diagnostics
+import store from "./store";
+$store = 1;
+
+```
diff --git a/crates/biome_js_parser/tests/spec_test.rs b/crates/biome_js_parser/tests/spec_test.rs
index ef798d7b274d..3bd175bd394f 100644
--- a/crates/biome_js_parser/tests/spec_test.rs
+++ b/crates/biome_js_parser/tests/spec_test.rs
@@ -85,8 +85,10 @@ pub fn run(test_case: &str, _snapshot_name: &str, test_directory: &str, outcome_
     // This simulates how template expressions are parsed in frameworks like Vue, Svelte, and Astro
     if file_name.contains(".inline_expr.") {
         // Use Svelte embedding kind for testing (any embedding kind would work)
-        file_source = file_source
-            .with_embedding_kind(biome_js_syntax::EmbeddingKind::Svelte { is_source: false });
+        file_source = file_source.with_embedding_kind(biome_js_syntax::EmbeddingKind::Svelte {
+            is_source: false,
+            kind: biome_js_syntax::SvelteFileKind::Component,
+        });
     }
 
     let extension = file_source.file_extension();
diff --git a/crates/biome_js_semantic/src/events.rs b/crates/biome_js_semantic/src/events.rs
index b65465ed5804..6672f5142f2f 100644
--- a/crates/biome_js_semantic/src/events.rs
+++ b/crates/biome_js_semantic/src/events.rs
@@ -15,7 +15,7 @@ use rustc_hash::FxHashMap;
 use std::collections::VecDeque;
 use std::mem;
 
-use crate::ScopeId;
+use crate::{ScopeId, SemanticFlavor};
 
 /// Events emitted by the [SemanticEventExtractor].
 /// These events are later made into the Semantic Model.
@@ -161,6 +161,7 @@ pub struct SemanticEventExtractor {
     /// Type parameters bound in a `infer T` clause.
     infers: Vec<TsTypeParameterName>,
     is_ambient_context: bool,
+    flavor: SemanticFlavor,
 }
 
 /// A binding name is either a type or a value.
@@ -1018,6 +1019,28 @@ impl SemanticEventExtractor {
         self.stash.pop_front()
     }
 
+    pub fn set_flavor(&mut self, flavor: SemanticFlavor) {
+        self.flavor = flavor;
+    }
+
+    fn maybe_svelte_store_dereference_binding_name(
+        &self,
+        name: &BindingName,
+    ) -> Option<BindingName> {
+        let BindingName::Value(name) = name else {
+            return None;
+        };
+        if self.flavor != SemanticFlavor::Svelte {
+            return None;
+        }
+        let store_name = self.flavor.store_reference_name(name.text())?;
+        let store_name_start = name.len() - TextSize::from(u32::try_from(store_name.len()).ok()?);
+        Some(BindingName::Value(
+            name.clone()
+                .slice(TextRange::new(store_name_start, name.len())),
+        ))
+    }
+
     fn push_infers_in_scope(&mut self) {
         let infers = mem::take(&mut self.infers);
         for infer in infers {
@@ -1073,152 +1096,50 @@ impl SemanticEventExtractor {
 
         // Bind references to declarations
         for (name, mut references) in scope.references {
-            if let Some(info) = self.bindings.get(&name) {
-                let declaration_at = info.range_start;
-                // We know the declaration of these reference.
-                for reference in references {
-                    let declaration_before_reference = declaration_at < reference.range().start();
-                    let event = match reference {
-                        Reference::Export(range) => {
-                            self.stash.push_back(SemanticEvent::Export {
-                                range,
-                                declaration_at,
-                            });
-                            if declaration_before_reference {
-                                SemanticEvent::Read {
-                                    range,
-                                    declaration_at,
-                                    scope_id,
-                                }
-                            } else {
-                                SemanticEvent::HoistedRead {
-                                    range,
-                                    declaration_at,
-                                    scope_id,
-                                }
-                            }
-                        }
-                        reference @ (Reference::Read(_) | Reference::AmbientRead(_)) => {
-                            if info.declaration_kind == JsSyntaxKind::JS_NAMESPACE_IMPORT_SPECIFIER
-                                && matches!(name, BindingName::Type(_))
-                            {
-                                // An import namespace imported as a type can only be
-                                // used in a qualified name, e.g `Namespace.Type`.
-                                // Thus, the reference is unresolved.
-                                // Note that we don't need to forward the reference in a parent scope,
-                                // because an import namespace is already in the root scope.
-                                self.stash.push_back(SemanticEvent::UnresolvedReference {
-                                    is_read: !reference.is_write(),
-                                    range: reference.range(),
-                                });
-                            }
-                            // Handle edge case where a non-import binding shadows a type import
-                            // and the reference appears in a type position (AmbientRead).
-                            // For example `(stream: stream.T) => {}` (parameter shadows import)
-                            // or `let hast: hast.Root` inside a block (variable shadows import)
-                            // In these cases, the reference should be promoted to the parent scope
-                            // so that the dual lookup can resolve it to the type-only import.
-                            //
-                            // We only promote when a dual imported binding actually exists
-                            // in an ancestor scope. Without this check, `typeof a` references
-                            // (which are AmbientRead on BindingName::Value) would be incorrectly
-                            // promoted instead of resolving to the local value binding (#9519).
-                            if reference.is_ambient_read()
-                                && !info.is_imported()
-                                && self
-                                    .bindings
-                                    .get(&name.clone().dual())
-                                    .is_some_and(|dual| dual.is_imported())
-                                && let Some(parent) = self.scopes.last_mut()
-                            {
-                                // Promote this reference to the parent scope
-                                let parent_references =
-                                    parent.references.entry(name.clone()).or_default();
-                                parent_references.push(Reference::AmbientRead(reference.range()));
-                                continue;
-                            }
-                            if declaration_before_reference {
-                                SemanticEvent::Read {
-                                    range: reference.range(),
-                                    declaration_at,
-                                    scope_id,
-                                }
-                            } else {
-                                SemanticEvent::HoistedRead {
-                                    range: reference.range(),
-                                    declaration_at,
-                                    scope_id,
-                                }
-                            }
-                        }
-                        Reference::Write(range) => {
-                            if declaration_before_reference {
-                                SemanticEvent::Write {
-                                    range,
-                                    declaration_at,
-                                    scope_id,
-                                }
-                            } else {
-                                SemanticEvent::HoistedWrite {
-                                    range,
-                                    declaration_at,
-                                    scope_id,
-                                }
-                            }
-                        }
-                    };
-                    self.stash.push_back(event);
+            if let Some(info) = self.bindings.get(&name).cloned() {
+                self.resolve_references_in_scope(name, references, &info, scope_id);
+                continue;
+            }
+
+            if let Some(info) = self.bindings.get(&name.clone().dual()).cloned() {
+                self.resolve_references_in_dual_scope(name, references, &info);
+                continue;
+            }
+
+            let fallback_name = self.maybe_svelte_store_dereference_binding_name(&name);
+            if let Some(fallback_name) = fallback_name {
+                // `$store = ...` updates the store value in Svelte; it is not a write to the
+                // backing `store` binding, so treat fallback writes as reads.
+                normalize_svelte_store_write_references(&mut references);
+
+                if let Some(info) = self.bindings.get(&fallback_name).cloned() {
+                    self.resolve_references_in_scope(fallback_name, references, &info, scope_id);
+                    continue;
                 }
-            } else if let Some(info) = self.bindings.get(&name.clone().dual()) {
-                let mut parent_references = self
-                    .scopes
-                    .last_mut()
-                    .map(|parent| parent.references.entry(name.clone()).or_default());
-                let is_dual_imported = info.is_imported();
-                for reference in references {
-                    match reference {
-                        Reference::Export(_) => {
-                            // An export can export both a value and a type.
-                            // If a dual binding exists, then it exports the dual binding.
-                        }
-                        Reference::AmbientRead(range) if is_dual_imported => {
-                            // An ambient read can only read a value,
-                            // but also an imported value as a type (with the `type` modifier)
-                            let declaration_before_reference =
-                                info.range_start < reference.range().start();
-                            let event = if declaration_before_reference {
-                                SemanticEvent::Read {
-                                    range,
-                                    declaration_at: info.range_start,
-                                    scope_id: ScopeId::new(0),
-                                }
-                            } else {
-                                SemanticEvent::HoistedRead {
-                                    range,
-                                    declaration_at: info.range_start,
-                                    scope_id: ScopeId::new(0),
-                                }
-                            };
-                            self.stash.push_back(event);
-                        }
-                        reference => {
-                            if let Some(parent_references) = &mut parent_references {
-                                parent_references.push(reference);
-                            } else {
-                                self.stash.push_back(SemanticEvent::UnresolvedReference {
-                                    is_read: !reference.is_write(),
-                                    range: reference.range(),
-                                });
-                            }
-                        }
+
+                if let Some(info) = self.bindings.get(&fallback_name.clone().dual()).cloned() {
+                    self.resolve_references_in_dual_scope(fallback_name, references, &info);
+                    continue;
+                }
+
+                if let Some(parent) = self.scopes.last_mut() {
+                    let parent_references = parent.references.entry(fallback_name).or_default();
+                    parent_references.append(&mut references);
+                } else {
+                    for reference in references {
+                        self.stash.push_back(SemanticEvent::UnresolvedReference {
+                            is_read: !reference.is_write(),
+                            range: reference.range(),
+                        });
                     }
                 }
-            } else if let Some(parent) = self.scopes.last_mut() {
-                // Promote these references to the parent scope
+                continue;
+            }
+
+            if let Some(parent) = self.scopes.last_mut() {
                 let parent_references = parent.references.entry(name).or_default();
                 parent_references.append(&mut references);
             } else {
-                // We are in the global scope. Raise `UnresolvedReference`.
                 for reference in references {
                     self.stash.push_back(SemanticEvent::UnresolvedReference {
                         is_read: !reference.is_write(),
@@ -1246,6 +1167,154 @@ impl SemanticEventExtractor {
         self.scopes.last_mut().unwrap()
     }
 
+    fn resolve_references_in_scope(
+        &mut self,
+        name: BindingName,
+        references: Vec<Reference>,
+        info: &BindingInfo,
+        scope_id: ScopeId,
+    ) {
+        let declaration_at = info.range_start;
+        for reference in references {
+            let declaration_before_reference = declaration_at < reference.range().start();
+            let event = match reference {
+                Reference::Export(range) => {
+                    self.stash.push_back(SemanticEvent::Export {
+                        range,
+                        declaration_at,
+                    });
+                    if declaration_before_reference {
+                        SemanticEvent::Read {
+                            range,
+                            declaration_at,
+                            scope_id,
+                        }
+                    } else {
+                        SemanticEvent::HoistedRead {
+                            range,
+                            declaration_at,
+                            scope_id,
+                        }
+                    }
+                }
+                reference @ (Reference::Read(_) | Reference::AmbientRead(_)) => {
+                    if info.declaration_kind == JsSyntaxKind::JS_NAMESPACE_IMPORT_SPECIFIER
+                        && matches!(&name, BindingName::Type(_))
+                    {
+                        // An import namespace imported as a type can only be
+                        // used in a qualified name, e.g `Namespace.Type`.
+                        // Thus, the reference is unresolved.
+                        // Note that we don't need to forward the reference in a parent scope,
+                        // because an import namespace is already in the root scope.
+                        // TODO(semantic-invalid-namespace-type-ref): Split semantic events for
+                        // invalid namespace-type references from usage tracking. We currently
+                        // emit both unresolved and read events so `noUndeclaredVariables` and
+                        // `noUnusedImports` stay consistent.
+                        self.stash.push_back(SemanticEvent::UnresolvedReference {
+                            is_read: !reference.is_write(),
+                            range: reference.range(),
+                        });
+                    }
+                    // A value binding can shadow a type-only import with the same name.
+                    // Promote ambient reads so the parent scope can resolve the type binding.
+                    // Only do this when the dual binding is imported; otherwise `typeof a`
+                    // should keep resolving to the local value binding (#9519).
+                    if reference.is_ambient_read()
+                        && !info.is_imported()
+                        && self
+                            .bindings
+                            .get(&name.clone().dual())
+                            .is_some_and(|dual| dual.is_imported())
+                        && let Some(parent) = self.scopes.last_mut()
+                    {
+                        let parent_references = parent.references.entry(name.clone()).or_default();
+                        parent_references.push(Reference::AmbientRead(reference.range()));
+                        continue;
+                    }
+                    if declaration_before_reference {
+                        SemanticEvent::Read {
+                            range: reference.range(),
+                            declaration_at,
+                            scope_id,
+                        }
+                    } else {
+                        SemanticEvent::HoistedRead {
+                            range: reference.range(),
+                            declaration_at,
+                            scope_id,
+                        }
+                    }
+                }
+                Reference::Write(range) => {
+                    if declaration_before_reference {
+                        SemanticEvent::Write {
+                            range,
+                            declaration_at,
+                            scope_id,
+                        }
+                    } else {
+                        SemanticEvent::HoistedWrite {
+                            range,
+                            declaration_at,
+                            scope_id,
+                        }
+                    }
+                }
+            };
+            self.stash.push_back(event);
+        }
+    }
+
+    fn resolve_references_in_dual_scope(
+        &mut self,
+        name: BindingName,
+        references: Vec<Reference>,
+        info: &BindingInfo,
+    ) {
+        let mut parent_references = self
+            .scopes
+            .last_mut()
+            .map(|parent| parent.references.entry(name.clone()).or_default());
+        let is_dual_imported = info.is_imported();
+        for reference in references {
+            match reference {
+                Reference::Export(_) => {
+                    // An export can export both a value and a type.
+                    // If a dual binding exists, then it exports the dual binding.
+                }
+                Reference::AmbientRead(range) if is_dual_imported => {
+                    // An ambient read can only read a value,
+                    // but also an imported value as a type (with the `type` modifier)
+                    let declaration_before_reference = info.range_start < reference.range().start();
+                    let event = if declaration_before_reference {
+                        SemanticEvent::Read {
+                            range,
+                            declaration_at: info.range_start,
+                            scope_id: ScopeId::new(0),
+                        }
+                    } else {
+                        SemanticEvent::HoistedRead {
+                            range,
+                            declaration_at: info.range_start,
+                            scope_id: ScopeId::new(0),
+                        }
+                    };
+                    self.stash.push_back(event);
+                }
+                reference => {
+                    if let Some(parent_references) = &mut parent_references {
+                        parent_references.push(reference);
+                    } else {
+                        self.stash.push_back(SemanticEvent::UnresolvedReference {
+                            is_read: !reference.is_write(),
+                            range: reference.range(),
+                        });
+                    }
+                }
+            }
+        }
+    }
+
     /// Finds the scope where declarations that are hoisted will be declared at.
     /// For example:
     ///
@@ -1315,6 +1384,16 @@ impl SemanticEventExtractor {
     }
 }
 
+/// In Svelte fallback resolution, convert `$store = ...` references into reads of `store`.
+/// This keeps write-sensitive rules from treating auto-subscription updates as binding writes.
+fn normalize_svelte_store_write_references(references: &mut [Reference]) {
+    for reference in references {
+        if let Reference::Write(range) = reference {
+            *reference = Reference::Read(*range);
+        }
+    }
+}
+
 /// Extracts [SemanticEvent] from [SyntaxNode].
 /// See [semantic_events] how to create this iterator.
 struct SemanticEventIterator {
diff --git a/crates/biome_js_semantic/src/semantic_model.rs b/crates/biome_js_semantic/src/semantic_model.rs
index 475dd5f46695..6d43ec231ff0 100644
--- a/crates/biome_js_semantic/src/semantic_model.rs
+++ b/crates/biome_js_semantic/src/semantic_model.rs
@@ -1,6 +1,7 @@
 mod binding;
 mod builder;
 mod closure;
+mod flavor;
 mod globals;
 mod import;
 mod is_constant;
@@ -13,9 +14,9 @@ mod tests;
 
 use crate::{SemanticEvent, SemanticEventExtractor};
 use biome_js_syntax::{
-    AnyJsExpression, AnyJsRoot, JsIdentifierAssignment, JsIdentifierBinding, JsLanguage,
-    JsReferenceIdentifier, JsSyntaxKind, JsSyntaxNode, JsxReferenceIdentifier, TextRange, TextSize,
-    TsIdentifierBinding,
+    AnyJsExpression, AnyJsRoot, JsFileSource, JsIdentifierAssignment, JsIdentifierBinding,
+    JsLanguage, JsReferenceIdentifier, JsSyntaxKind, JsSyntaxNode, JsxReferenceIdentifier,
+    TextRange, TextSize, TsIdentifierBinding,
 };
 use biome_rowan::AstNode;
 pub use closure::*;
@@ -29,6 +30,7 @@ use std::{
 pub use binding::*;
 pub use builder::*;
 
+pub use flavor::*;
 pub use globals::*;
 pub use import::*;
 pub use is_constant::*;
@@ -41,6 +43,17 @@ pub use scope::*;
 pub struct SemanticModelOptions {
     /// All the allowed globals names
     pub globals: FxHashSet<String>,
+    /// Additional semantic behavior for embedded/framework-specific syntax.
+    pub flavor: SemanticFlavor,
+}
+
+impl From<&JsFileSource> for SemanticModelOptions {
+    fn from(source_type: &JsFileSource) -> Self {
+        Self {
+            flavor: source_type.into(),
+            ..Self::default()
+        }
+    }
 }
 
 /// Build the complete [SemanticModel] of a parsed file.
@@ -49,7 +62,9 @@ pub fn semantic_model(root: &AnyJsRoot, options: SemanticModelOptions) -> Semant
     let mut extractor = SemanticEventExtractor::default();
     let mut builder = SemanticModelBuilder::new(root.clone());
 
-    let SemanticModelOptions { globals } = options;
+    let SemanticModelOptions { globals, flavor } = options;
+    extractor.set_flavor(flavor);
+    builder.set_flavor(flavor);
 
     for global in globals {
         builder.push_global(global);
diff --git a/crates/biome_js_semantic/src/semantic_model/builder.rs b/crates/biome_js_semantic/src/semantic_model/builder.rs
index 0aa233f795b8..4673f9b6204f 100644
--- a/crates/biome_js_semantic/src/semantic_model/builder.rs
+++ b/crates/biome_js_semantic/src/semantic_model/builder.rs
@@ -1,8 +1,10 @@
 use super::*;
-use biome_js_syntax::{AnyJsRoot, JsSyntaxNode, TextRange, TsConditionalType, TsTypeParameterName};
+use biome_js_syntax::{
+    AnyJsRoot, JsIdentifierAssignment, JsSyntaxNode, TextRange, TsConditionalType,
+    TsTypeParameterName,
+};
 use biome_rowan::SyntaxNodePtr;
 use rustc_hash::{FxHashMap, FxHashSet};
-use std::collections::hash_map::Entry;
 
 /// Builds the [SemanticModel] consuming [SemanticEvent] and [JsSyntaxNode].
 /// For a good example on how to use it see [semantic_model].
@@ -27,6 +29,7 @@ pub struct SemanticModelBuilder {
     declared_at_by_start: FxHashMap<TextSize, BindingId>,
     exported: FxHashSet<TextSize>,
     unresolved_references: Vec<SemanticModelUnresolvedReference>,
+    flavor: SemanticFlavor,
 }
 
 impl SemanticModelBuilder {
@@ -45,9 +48,15 @@ impl SemanticModelBuilder {
             declared_at_by_start: FxHashMap::default(),
             exported: FxHashSet::default(),
             unresolved_references: Vec::new(),
+            flavor: SemanticFlavor::default(),
         }
     }
 
+    #[inline]
+    pub fn set_flavor(&mut self, flavor: SemanticFlavor) {
+        self.flavor = flavor;
+    }
+
     #[inline]
     pub fn push_node(&mut self, node: &JsSyntaxNode) {
         use JsSyntaxKind::*;
@@ -242,7 +251,11 @@ impl SemanticModelBuilder {
                 let scope = &mut self.scopes[scope_id.index()];
                 scope.read_references.push(reference_id);
 
-                self.declared_at_by_start.insert(range.start(), binding_id);
+                // `$store = ...` in Svelte is not a write to the `store` binding itself.
+                // Skipping this index keeps write-sensitive rules from reporting false positives.
+                if !self.is_svelte_store_assignment(range) {
+                    self.declared_at_by_start.insert(range.start(), binding_id);
+                }
             }
             HoistedRead {
                 range,
@@ -260,7 +273,9 @@ impl SemanticModelBuilder {
                 let scope = &mut self.scopes[scope_id.index()];
                 scope.read_references.push(reference_id);
 
-                self.declared_at_by_start.insert(range.start(), binding_id);
+                if !self.is_svelte_store_assignment(range) {
+                    self.declared_at_by_start.insert(range.start(), binding_id);
+                }
             }
             Write {
                 range,
@@ -306,35 +321,33 @@ impl SemanticModelBuilder {
                 };
 
                 let node = &self.binding_node_by_start[&range.start()];
-                let name = node.text_trimmed().to_string();
-
-                match self.globals_by_name.entry(name) {
-                    Entry::Occupied(mut entry) => {
-                        let entry = entry.get_mut();
-                        match entry {
-                            Some(index) => {
-                                self.globals[(*index) as usize].references.push(
-                                    SemanticModelGlobalReferenceData {
-                                        range_start: range.start(),
-                                        ty,
-                                    },
-                                );
-                            }
-                            None => {
-                                let id = self.globals.len() as u32;
-                                self.globals.push(SemanticModelGlobalBindingData {
-                                    references: vec![SemanticModelGlobalReferenceData {
-                                        range_start: range.start(),
-                                        ty,
-                                    }],
-                                });
-                                *entry = Some(id);
-                            }
-                        }
+                let unresolved_name = node.text_trimmed().to_string();
+
+                if let Some(global_name) = self.resolve_global_name(&unresolved_name) {
+                    if let Some(index) = self.globals_by_name[global_name] {
+                        self.globals[index as usize].references.push(
+                            SemanticModelGlobalReferenceData {
+                                range_start: range.start(),
+                                ty,
+                            },
+                        );
+                    } else {
+                        let id = self.globals.len() as u32;
+                        self.globals.push(SemanticModelGlobalBindingData {
+                            references: vec![SemanticModelGlobalReferenceData {
+                                range_start: range.start(),
+                                ty,
+                            }],
+                        });
+                        *self
+                            .globals_by_name
+                            .get_mut(global_name)
+                            .expect("resolved global name must exist in globals_by_name") =
+                            Some(id);
                     }
-                    Entry::Vacant(_) => self
-                        .unresolved_references
-                        .push(SemanticModelUnresolvedReference { range }),
+                } else {
+                    self.unresolved_references
+                        .push(SemanticModelUnresolvedReference { range });
                 }
             }
             Export {
@@ -354,6 +367,7 @@ impl SemanticModelBuilder {
     pub fn build(self) -> SemanticModel {
         let data = SemanticModelData {
             root: self.root.syntax().as_send().expect("To be a root node"),
+            flavor: self.flavor,
             scopes: self.scopes,
             scope_by_range: Lapper::new(
                 self.scope_range_by_start
@@ -382,4 +396,43 @@ impl SemanticModelBuilder {
         };
         SemanticModel::new(data)
     }
+
+    fn resolve_global_name<'a>(&self, unresolved_name: &'a str) -> Option<&'a str> {
+        if self.globals_by_name.contains_key(unresolved_name) {
+            return Some(unresolved_name);
+        }
+
+        if self.flavor == SemanticFlavor::Svelte
+            && let Some(store_name) = self.flavor.store_reference_name(unresolved_name)
+            && self.globals_by_name.contains_key(store_name)
+        {
+            return Some(store_name);
+        }
+
+        None
+    }
+
+    /// Returns true for references that come from Svelte `$store = ...` updates.
+    /// Those updates should not be treated like writes to the backing `store` binding.
+    fn is_svelte_store_assignment(&self, range: TextRange) -> bool {
+        if self.flavor != SemanticFlavor::Svelte {
+            return false;
+        }
+        let Some(node) = self.binding_node_by_start.get(&range.start()) else {
+            return false;
+        };
+        if node.kind() != JsSyntaxKind::JS_IDENTIFIER_ASSIGNMENT {
+            return false;
+        }
+
+        let Some(identifier_assignment) = JsIdentifierAssignment::cast_ref(node) else {
+            return false;
+        };
+        let Ok(reference_name) = identifier_assignment.name_token() else {
+            return false;
+        };
+        self.flavor
+            .store_reference_name(reference_name.text_trimmed())
+            .is_some()
+    }
 }
diff --git a/crates/biome_js_semantic/src/semantic_model/flavor.rs b/crates/biome_js_semantic/src/semantic_model/flavor.rs
new file mode 100644
index 000000000000..22cb0670daaf
--- /dev/null
+++ b/crates/biome_js_semantic/src/semantic_model/flavor.rs
@@ -0,0 +1,52 @@
+use biome_js_syntax::JsFileSource;
+
+#[derive(Debug, Clone, Copy, Default, PartialEq, Eq)]
+pub enum SemanticFlavor {
+    /// Regular JavaScript/TypeScript semantics.
+    #[default]
+    Vanilla,
+    /// Svelte-specific semantics, such as `$store` dereference syntax.
+    Svelte,
+}
+
+pub const SVELTE_RUNES: [&str; 7] = [
+    "$bindable",
+    "$derived",
+    "$effect",
+    "$host",
+    "$inspect",
+    "$props",
+    "$state",
+];
+
+impl SemanticFlavor {
+    pub fn is_svelte_rune(self, name: &str) -> bool {
+        self == Self::Svelte && SVELTE_RUNES.contains(&name)
+    }
+
+    /// Returns the store binding name for Svelte auto-subscription references (`$store` -> `store`).
+    /// It only matches a single leading `$` and excludes runes.
+    pub fn store_reference_name(self, reference_name: &str) -> Option<&str> {
+        if self != Self::Svelte {
+            return None;
+        }
+        if self.is_svelte_rune(reference_name) {
+            return None;
+        }
+        let store_name = reference_name.strip_prefix('$')?;
+        if store_name.is_empty() || store_name.starts_with('$') {
+            return None;
+        }
+        Some(store_name)
+    }
+}
+
+impl From<&JsFileSource> for SemanticFlavor {
+    fn from(source_type: &JsFileSource) -> Self {
+        if source_type.as_embedding_kind().is_svelte() {
+            Self::Svelte
+        } else {
+            Self::Vanilla
+        }
+    }
+}
diff --git a/crates/biome_js_semantic/src/semantic_model/model.rs b/crates/biome_js_semantic/src/semantic_model/model.rs
index 9c8dd81a027a..9509250f72c0 100644
--- a/crates/biome_js_semantic/src/semantic_model/model.rs
+++ b/crates/biome_js_semantic/src/semantic_model/model.rs
@@ -73,6 +73,7 @@ impl ScopeId {
 #[derive(Debug)]
 pub(crate) struct SemanticModelData {
     pub(crate) root: SendNode,
+    pub(crate) flavor: SemanticFlavor,
     // All scopes of this model
     pub(crate) scopes: Vec<SemanticModelScopeData>,
     pub(crate) scope_by_range: rust_lapper::Lapper<u32, ScopeId>,
@@ -193,6 +194,11 @@ impl SemanticModel {
         self.data.root.to_language_root::<AnyJsRoot>()
     }
 
+    /// Returns the framework-specific semantic flavor used to build this model.
+    pub fn flavor(&self) -> SemanticFlavor {
+        self.data.flavor
+    }
+
     /// Iterate all scopes
     pub fn scopes(&self) -> impl Iterator<Item = Scope> + '_ {
         self.data.scopes.iter().enumerate().map(|(id, _)| Scope {
diff --git a/crates/biome_js_semantic/src/semantic_model/tests.rs b/crates/biome_js_semantic/src/semantic_model/tests.rs
index ff15ea466c6a..69e236d72d32 100644
--- a/crates/biome_js_semantic/src/semantic_model/tests.rs
+++ b/crates/biome_js_semantic/src/semantic_model/tests.rs
@@ -1,8 +1,8 @@
 #[cfg(test)]
 mod test {
     use crate::{
-        BindingExtensions, CanBeImportedExported, SemanticModelOptions, SemanticScopeExtensions,
-        semantic_model,
+        BindingExtensions, CanBeImportedExported, SemanticFlavor, SemanticModelOptions,
+        SemanticScopeExtensions, semantic_model,
     };
     use biome_js_parser::JsParserOptions;
     use biome_js_syntax::{
@@ -11,6 +11,13 @@ mod test {
     };
     use biome_rowan::{AstNode, SyntaxNodeCast};
 
+    fn svelte_options() -> SemanticModelOptions {
+        SemanticModelOptions {
+            flavor: SemanticFlavor::Svelte,
+            ..SemanticModelOptions::default()
+        }
+    }
+
     #[test]
     pub fn ok_semantic_model() {
         let r = biome_js_parser::parse(
@@ -331,4 +338,137 @@ declare module "jsoneditor" {
             missing_scopes.join("\n")
         );
     }
+
+    #[test]
+    pub fn ok_semantic_model_namespace_import_type_unqualified_reference_is_unresolved_and_tracked_for_usage()
+     {
+        let r = biome_js_parser::parse(
+            "import type * as Namespace from \"mod\"; type T = Namespace;",
+            JsFileSource::ts(),
+            JsParserOptions::default(),
+        );
+        let model = semantic_model(&r.tree(), SemanticModelOptions::default());
+
+        let namespace_binding = model
+            .global_scope()
+            .get_binding("Namespace")
+            .expect("expected Namespace binding");
+        // TODO(semantic-invalid-namespace-type-ref): This currently tracks a read to keep
+        // `noUnusedImports` behavior while still emitting unresolved diagnostics.
+        assert_eq!(namespace_binding.all_references().count(), 1);
+
+        let mut unresolved_references = model.all_unresolved_references();
+        let unresolved_reference = unresolved_references
+            .next()
+            .expect("expected one unresolved reference");
+        assert_eq!(
+            unresolved_reference.tree().syntax().text_trimmed(),
+            "Namespace"
+        );
+        assert!(unresolved_references.next().is_none());
+    }
+
+    #[test]
+    pub fn ok_semantic_model_svelte_store_dereference() {
+        let r = biome_js_parser::parse(
+            "const store = 1; $store;",
+            JsFileSource::ts(),
+            JsParserOptions::default(),
+        );
+        let model = semantic_model(&r.tree(), svelte_options());
+
+        assert_eq!(model.all_unresolved_references().count(), 0);
+    }
+
+    #[test]
+    pub fn ok_semantic_model_svelte_rune_is_not_normalized_as_store() {
+        let r = biome_js_parser::parse(
+            "const state = 1; $state;",
+            JsFileSource::ts(),
+            JsParserOptions::default(),
+        );
+        let model = semantic_model(&r.tree(), svelte_options());
+
+        let mut unresolved_references = model.all_unresolved_references();
+        let unresolved_reference = unresolved_references
+            .next()
+            .expect("expected one unresolved reference");
+        assert_eq!(
+            unresolved_reference.tree().syntax().text_trimmed(),
+            "$state"
+        );
+        assert!(unresolved_references.next().is_none());
+    }
+
+    #[test]
+    pub fn ok_semantic_model_svelte_dollar_identifier_binding_uses_exact_name() {
+        let r = biome_js_parser::parse(
+            "const $store = 1; $store;",
+            JsFileSource::ts(),
+            JsParserOptions::default(),
+        );
+        let model = semantic_model(&r.tree(), svelte_options());
+
+        assert_eq!(model.all_unresolved_references().count(), 0);
+    }
+
+    #[test]
+    pub fn ok_semantic_model_svelte_store_dereference_can_resolve_outer_value_binding() {
+        let r = biome_js_parser::parse(
+            "const store = 1; { type store = number; $store; }",
+            JsFileSource::ts(),
+            JsParserOptions::default(),
+        );
+        let model = semantic_model(&r.tree(), svelte_options());
+
+        assert_eq!(model.all_unresolved_references().count(), 0);
+    }
+
+    #[test]
+    pub fn ok_semantic_model_svelte_store_dereference_resolves_configured_global() {
+        let r = biome_js_parser::parse("$store;", JsFileSource::ts(), JsParserOptions::default());
+        let mut options = svelte_options();
+        options.globals.insert("store".into());
+
+        let model = semantic_model(&r.tree(), options);
+
+        assert_eq!(model.all_unresolved_references().count(), 0);
+        assert_eq!(model.all_global_references().count(), 1);
+    }
+
+    #[test]
+    pub fn ok_semantic_model_svelte_double_dollar_reference_is_not_normalized() {
+        let r = biome_js_parser::parse("$$state;", JsFileSource::ts(), JsParserOptions::default());
+        let mut options = svelte_options();
+        options.globals.insert("$state".into());
+
+        let model = semantic_model(&r.tree(), options);
+
+        assert_eq!(model.all_unresolved_references().count(), 1);
+        assert_eq!(model.all_global_references().count(), 0);
+    }
+
+    #[test]
+    pub fn ok_semantic_model_svelte_store_assignment_is_not_tracked_as_binding_write() {
+        let r = biome_js_parser::parse(
+            "const store = 1; $store = 2;",
+            JsFileSource::ts(),
+            JsParserOptions::default(),
+        );
+        let model = semantic_model(&r.tree(), svelte_options());
+
+        let store_binding = model
+            .global_scope()
+            .get_binding("store")
+            .expect("expected store binding");
+        assert_eq!(store_binding.all_writes().count(), 0);
+        assert_eq!(store_binding.all_reads().count(), 1);
+
+        let assignment = r
+            .syntax()
+            .descendants()
+            .find_map(JsIdentifierAssignment::cast)
+            .expect("expected an assignment");
+        assert!(model.binding(&assignment).is_none());
+    }
 }
diff --git a/crates/biome_js_syntax/src/file_source.rs b/crates/biome_js_syntax/src/file_source.rs
index f97c8fc7b5d9..6e97dbd85eb2 100644
--- a/crates/biome_js_syntax/src/file_source.rs
+++ b/crates/biome_js_syntax/src/file_source.rs
@@ -115,6 +115,24 @@ impl Language {
         )
     }
 }
+#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
+#[derive(
+    Debug, Clone, Default, Copy, Eq, PartialEq, Hash, serde::Serialize, serde::Deserialize,
+)]
+pub enum SvelteFileKind {
+    /// A `.svelte` component document where JavaScript is extracted from `<script>` blocks.
+    ///
+    /// Component documents still need Svelte-specific parsing and may re-infer
+    /// their JS/TS source type from `<script ...>` content.
+    #[default]
+    Component,
+    /// A `.svelte.js` / `.svelte.ts` source module parsed as a regular JS/TS module.
+    ///
+    /// Source modules already carry their JS/TS source type and should use the
+    /// normal JS document capabilities directly instead of component extraction.
+    SourceModule,
+}
+
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
 #[derive(
     Debug, Clone, Default, Copy, Eq, PartialEq, Hash, serde::Serialize, serde::Deserialize,
@@ -139,6 +157,11 @@ pub enum EmbeddingKind {
     Svelte {
         /// Where the bindings are defined
         is_source: bool,
+        /// `kind` models whether the Svelte file is a component document or a
+        /// source module. That distinction controls whether downstream code
+        /// extracts `<script>` content or treats the file as a standalone JS/TS
+        /// module, while `is_source` still tracks where bindings come from.
+        kind: SvelteFileKind,
     },
     #[default]
     None,
@@ -169,6 +192,24 @@ impl EmbeddingKind {
     pub const fn is_svelte(&self) -> bool {
         matches!(self, Self::Svelte { .. })
     }
+    pub const fn is_svelte_component(&self) -> bool {
+        matches!(
+            self,
+            Self::Svelte {
+                kind: SvelteFileKind::Component,
+                ..
+            }
+        )
+    }
+    pub const fn is_svelte_source_module(&self) -> bool {
+        matches!(
+            self,
+            Self::Svelte {
+                kind: SvelteFileKind::SourceModule,
+                ..
+            }
+        )
+    }
 }
 
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
@@ -258,7 +299,10 @@ impl JsFileSource {
 
     /// Svelte file definition
     pub fn svelte() -> Self {
-        Self::js_module().with_embedding_kind(EmbeddingKind::Svelte { is_source: true })
+        Self::js_module().with_embedding_kind(EmbeddingKind::Svelte {
+            is_source: true,
+            kind: SvelteFileKind::Component,
+        })
     }
 
     pub const fn with_module_kind(mut self, kind: ModuleKind) -> Self {
@@ -332,12 +376,13 @@ impl JsFileSource {
     pub const fn is_embedded_source(&self) -> bool {
         matches!(
             self.embedding_kind,
-            EmbeddingKind::Svelte { is_source: true }
-                | EmbeddingKind::Vue {
-                    is_source: true,
-                    ..
-                }
-                | EmbeddingKind::Astro { frontmatter: true }
+            EmbeddingKind::Svelte {
+                is_source: true,
+                ..
+            } | EmbeddingKind::Vue {
+                is_source: true,
+                ..
+            } | EmbeddingKind::Astro { frontmatter: true }
         )
     }
 
@@ -348,12 +393,13 @@ impl JsFileSource {
     pub const fn is_template_expression(&self) -> bool {
         matches!(
             self.embedding_kind,
-            EmbeddingKind::Svelte { is_source: false }
-                | EmbeddingKind::Vue {
-                    allow_statements: false,
-                    ..
-                }
-                | EmbeddingKind::Astro { frontmatter: false }
+            EmbeddingKind::Svelte {
+                is_source: false,
+                ..
+            } | EmbeddingKind::Vue {
+                allow_statements: false,
+                ..
+            } | EmbeddingKind::Astro { frontmatter: false }
         )
     }
 
@@ -366,6 +412,14 @@ impl JsFileSource {
         &self.embedding_kind
     }
 
+    pub const fn is_svelte_component(&self) -> bool {
+        self.embedding_kind.is_svelte_component()
+    }
+
+    pub const fn is_svelte_source_module(&self) -> bool {
+        self.embedding_kind.is_svelte_source_module()
+    }
+
     pub fn file_extension(&self) -> &str {
         match self.language {
             Language::JavaScript => {
@@ -393,17 +447,56 @@ impl JsFileSource {
         }
     }
 
+    /// Returns whether the path points to a Svelte source-module file.
+    ///
+    /// These files are JavaScript/TypeScript modules with Svelte semantics
+    /// (for example, `$store` auto-subscriptions), not `.svelte` component
+    /// documents with embedded `<script>` content.
+    pub fn is_svelte_source_module_path(path: &Utf8Path) -> bool {
+        let Some(file_name) = path
+            .file_name()
+            .map(|file_name| file_name.to_ascii_lowercase_cow())
+        else {
+            return false;
+        };
+
+        Self::is_svelte_source_module_file_name(file_name.as_ref())
+    }
+
+    fn is_svelte_source_module_file_name(file_name: &str) -> bool {
+        file_name.ends_with(".svelte.ts")
+            || file_name.ends_with(".svelte.test.ts")
+            || file_name.ends_with(".svelte.spec.ts")
+            || file_name.ends_with(".svelte.js")
+            || file_name.ends_with(".svelte.test.js")
+            || file_name.ends_with(".svelte.spec.js")
+    }
+
     /// Try to return the JS file source corresponding to this file name from well-known files
     pub fn try_from_well_known(path: &Utf8Path) -> Result<Self, FileSourceError> {
         // Be careful with definition files, because `Path::extension()` only
         // returns the extension after the _last_ dot:
-        let file_name = path.file_name().ok_or(FileSourceError::MissingFileName)?;
+        let file_name = path
+            .file_name()
+            .map(|file_name| file_name.to_ascii_lowercase_cow())
+            .ok_or(FileSourceError::MissingFileName)?;
         if file_name.ends_with(".d.ts") {
             return Self::try_from_extension("d.ts");
         } else if file_name.ends_with(".d.mts") {
             return Self::try_from_extension("d.mts");
         } else if file_name.ends_with(".d.cts") {
             return Self::try_from_extension("d.cts");
+        } else if Self::is_svelte_source_module_file_name(file_name.as_ref()) {
+            let source = if file_name.ends_with(".ts") {
+                Self::ts()
+            } else {
+                Self::js_module()
+            };
+
+            return Ok(source.with_embedding_kind(EmbeddingKind::Svelte {
+                is_source: true,
+                kind: SvelteFileKind::SourceModule,
+            }));
         }
 
         match path.extension() {
@@ -518,3 +611,24 @@ impl From<Language> for JsFileSource {
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn detects_svelte_typescript_source_modules_case_insensitively() {
+        let source = JsFileSource::try_from(Utf8Path::new("component.SVELTE.TS")).unwrap();
+
+        assert!(source.is_svelte_source_module());
+        assert!(source.is_typescript());
+    }
+
+    #[test]
+    fn detects_svelte_javascript_source_modules_case_insensitively() {
+        let source = JsFileSource::try_from(Utf8Path::new("component.SVELTE.TEST.JS")).unwrap();
+
+        assert!(source.is_svelte_source_module());
+        assert!(!source.is_typescript());
+    }
+}
diff --git a/crates/biome_service/src/file_handlers/css.rs b/crates/biome_service/src/file_handlers/css.rs
index b35ea39f4a2b..a9db4fa10753 100644
--- a/crates/biome_service/src/file_handlers/css.rs
+++ b/crates/biome_service/src/file_handlers/css.rs
@@ -607,6 +607,7 @@ pub(crate) fn code_actions(params: CodeActionsParams) -> PullActionsResult {
         categories,
         action_offset,
         document_services,
+        snippet_services: _,
     } = params;
     let tree = parse.tree();
     let Some(file_source) = language.to_css_file_source() else {
diff --git a/crates/biome_service/src/file_handlers/graphql.rs b/crates/biome_service/src/file_handlers/graphql.rs
index c5da43ec050c..bafc94c0e6fc 100644
--- a/crates/biome_service/src/file_handlers/graphql.rs
+++ b/crates/biome_service/src/file_handlers/graphql.rs
@@ -494,6 +494,7 @@ pub(crate) fn code_actions(params: CodeActionsParams) -> PullActionsResult {
         categories,
         action_offset,
         document_services: _,
+        snippet_services: _,
     } = params;
     let _ = debug_span!("Code actions GraphQL", range =? range, path =? path).entered();
     let tree = parse.tree();
diff --git a/crates/biome_service/src/file_handlers/html.rs b/crates/biome_service/src/file_handlers/html.rs
index 5e1b9793f28d..f5f46ec455c5 100644
--- a/crates/biome_service/src/file_handlers/html.rs
+++ b/crates/biome_service/src/file_handlers/html.rs
@@ -54,7 +54,7 @@ use biome_html_syntax::{
     VueVSlotShorthandDirective,
 };
 use biome_js_parser::parse_js_with_offset_and_cache;
-use biome_js_syntax::{EmbeddingKind, JsFileSource, JsLanguage};
+use biome_js_syntax::{EmbeddingKind, JsFileSource, JsLanguage, SvelteFileKind};
 use biome_json_parser::parse_json_with_offset_and_cache;
 use biome_json_syntax::{JsonFileSource, JsonLanguage};
 use biome_parser::AnyParse;
@@ -1141,8 +1141,10 @@ fn parse_matched_embed(
                 }
                 EmbedCandidate::Element { .. } => {
                     if ctx.host_file_source.is_svelte() {
-                        js_source = js_source
-                            .with_embedding_kind(EmbeddingKind::Svelte { is_source: true });
+                        js_source = js_source.with_embedding_kind(EmbeddingKind::Svelte {
+                            is_source: true,
+                            kind: SvelteFileKind::Component,
+                        });
                     } else if ctx.host_file_source.is_vue() {
                         js_source = js_source.with_embedding_kind(EmbeddingKind::Vue {
                             setup: candidate.has_attribute("setup"),
@@ -1163,8 +1165,10 @@ fn parse_matched_embed(
                         js_source = js_source
                             .with_embedding_kind(EmbeddingKind::Astro { frontmatter: false });
                     } else if ctx.host_file_source.is_svelte() {
-                        js_source = js_source
-                            .with_embedding_kind(EmbeddingKind::Svelte { is_source: false });
+                        js_source = js_source.with_embedding_kind(EmbeddingKind::Svelte {
+                            is_source: false,
+                            kind: SvelteFileKind::Component,
+                        });
                     } else if ctx.host_file_source.is_vue() {
                         js_source = js_source.with_embedding_kind(EmbeddingKind::Vue {
                             setup: false,
@@ -1182,24 +1186,21 @@ fn parse_matched_embed(
                     if let Some(efs) = embedded_file_source {
                         js_source = efs;
                     }
-                    match ctx.host_file_source.variant() {
-                        HtmlVariant::Standard(_) => {}
-                        HtmlVariant::Astro => {
-                            js_source = js_source
-                                .with_embedding_kind(EmbeddingKind::Astro { frontmatter: false });
-                        }
-                        HtmlVariant::Vue => {
-                            js_source = js_source.with_embedding_kind(EmbeddingKind::Vue {
-                                setup: false,
-                                is_source: false,
-                                event_handler: *is_event_handler,
-                                allow_statements: false,
-                            });
-                        }
-                        HtmlVariant::Svelte => {
-                            js_source = js_source
-                                .with_embedding_kind(EmbeddingKind::Svelte { is_source: false });
-                        }
+                    if ctx.host_file_source.is_svelte() {
+                        js_source = js_source.with_embedding_kind(EmbeddingKind::Svelte {
+                            is_source: false,
+                            kind: SvelteFileKind::Component,
+                        });
+                    } else if ctx.host_file_source.is_vue() {
+                        js_source = js_source.with_embedding_kind(EmbeddingKind::Vue {
+                            setup: false,
+                            is_source: false,
+                            event_handler: *is_event_handler,
+                            allow_statements: false,
+                        });
+                    } else if ctx.host_file_source.is_astro() {
+                        js_source = js_source
+                            .with_embedding_kind(EmbeddingKind::Astro { frontmatter: false });
                     }
 
                     false
@@ -1231,14 +1232,13 @@ fn parse_matched_embed(
                 content.content_offset,
             );
 
-            // Source-level embeds get full services; expression-level don't
-            let js_services = if is_source_level
-                && (ctx.settings.as_ref().is_linter_enabled()
-                    || ctx.settings.as_ref().is_assist_enabled())
-            {
-                JsDocumentServices::default()
-                    .with_js_semantic_model(&snippet.tree())
-                    .into()
+            let js_services = if is_source_level {
+                JsDocumentServices::from_js_snippet(
+                    &snippet.tree(),
+                    &js_source,
+                    ctx.settings.as_ref().is_linter_enabled()
+                        || ctx.settings.as_ref().is_assist_enabled(),
+                )
             } else {
                 DocumentServices::none()
             };
@@ -1507,6 +1507,7 @@ pub(crate) fn code_actions(params: CodeActionsParams) -> PullActionsResult {
         categories,
         action_offset,
         document_services: _,
+        snippet_services: _,
     } = params;
     let _ = debug_span!("Code actions HTML", range =? range, path =? path).entered();
     let tree = parse.tree();
diff --git a/crates/biome_service/src/file_handlers/javascript.rs b/crates/biome_service/src/file_handlers/javascript.rs
index 08bd5f355df2..9e3d9e52ba26 100644
--- a/crates/biome_service/src/file_handlers/javascript.rs
+++ b/crates/biome_service/src/file_handlers/javascript.rs
@@ -17,7 +17,9 @@ use crate::settings::{
     check_override_feature_activity,
 };
 use crate::workspace::document::services::embedded_bindings::EmbeddedBuilder;
-use crate::workspace::{DocumentFileSource, EmbeddedSnippet, PullDiagnosticsAndActionsResult};
+use crate::workspace::{
+    DocumentFileSource, DocumentServices, EmbeddedSnippet, PullDiagnosticsAndActionsResult,
+};
 use crate::{
     WorkspaceError,
     settings::{FormatSettings, LanguageListSettings, LanguageSettings, ServiceLanguage},
@@ -54,7 +56,7 @@ use biome_js_formatter::context::{
 };
 use biome_js_formatter::format_node;
 use biome_js_parser::JsParserOptions;
-use biome_js_semantic::{SemanticModelOptions, semantic_model};
+use biome_js_semantic::{SVELTE_RUNES, SemanticModelOptions, semantic_model};
 use biome_js_syntax::{
     AnyJsExpression, AnyJsRoot, AnyJsTemplateElement, JsCallArgumentList, JsCallArguments,
     JsCallExpression, JsClassDeclaration, JsClassExpression, JsFileSource, JsFunctionDeclaration,
@@ -363,8 +365,8 @@ impl ServiceLanguage for JsLanguage {
 
         globals.extend(overrides.override_js_globals(path, &global.languages.javascript.globals));
 
-        if let Some(filename) = path.file_name() {
-            if filename.ends_with(".vue") {
+        if let Ok(source_type) = JsFileSource::try_from(path.as_path()) {
+            if source_type.as_embedding_kind().is_vue() {
                 globals.extend(
                     [
                         "defineEmits",
@@ -377,29 +379,11 @@ impl ServiceLanguage for JsLanguage {
                     ]
                     .map(Into::into),
                 );
-            } else if filename.ends_with(".astro") {
+            } else if source_type.as_embedding_kind().is_astro() {
                 globals.extend(["Astro"].map(Into::into));
-            } else if filename.ends_with(".svelte")
-                || filename.ends_with(".svelte.js")
-                || filename.ends_with(".svelte.ts")
-                || filename.ends_with(".svelte.test.ts")
-                || filename.ends_with(".svelte.test.js")
-                || filename.ends_with(".svelte.spec.ts")
-                || filename.ends_with(".svelte.spec.js")
-            {
+            } else if source_type.as_embedding_kind().is_svelte() {
                 // Svelte 5 runes
-                globals.extend(
-                    [
-                        "$bindable",
-                        "$derived",
-                        "$effect",
-                        "$host",
-                        "$inspect",
-                        "$props",
-                        "$state",
-                    ]
-                    .map(Into::into),
-                );
+                globals.extend(SVELTE_RUNES.iter().copied().map(Into::into));
             }
         }
 
@@ -929,9 +913,10 @@ fn debug_registered_types(_path: &BiomePath, parse: AnyParse) -> Result<String,
     Ok(result)
 }
 
-fn debug_semantic_model(_path: &BiomePath, parse: AnyParse) -> Result<String, WorkspaceError> {
+fn debug_semantic_model(path: &BiomePath, parse: AnyParse) -> Result<String, WorkspaceError> {
     let tree: AnyJsRoot = parse.tree();
-    let model = semantic_model(&tree, SemanticModelOptions::default());
+    let source_type = JsFileSource::try_from(path.as_path()).unwrap_or_default();
+    let model = semantic_model(&tree, SemanticModelOptions::from(&source_type));
     Ok(model.to_string())
 }
 
@@ -939,10 +924,10 @@ pub(crate) fn lint(params: LintParams) -> LintResults {
     let _ =
         debug_span!("Linting JavaScript file", path =? params.path, language =? params.language)
             .entered();
-    let Some(file_source) = params
-        .language
-        .to_js_file_source()
-        .or(JsFileSource::try_from(params.path.as_path()).ok())
+    // Use snippet services (for embedded JS) if present, else document services.
+    let effective_services = params.snippet_services.unwrap_or(params.document_services);
+    let Some(file_source) =
+        js_source_type_for_analysis(params.path, &params.language, effective_services)
     else {
         return LintResults {
             errors: 0,
@@ -974,8 +959,6 @@ pub(crate) fn lint(params: LintParams) -> LintResults {
 
     let mut process_lint = ProcessLint::new(&params);
 
-    // Use snippet services (for embedded JS) if present, else document services.
-    let effective_services = params.snippet_services.unwrap_or(params.document_services);
     let semantic_model = effective_services
         .as_js_services()
         .and_then(|s| s.semantic_model.clone());
@@ -1029,6 +1012,7 @@ pub(crate) fn code_actions(params: CodeActionsParams) -> PullActionsResult {
         categories,
         action_offset,
         document_services,
+        snippet_services,
     } = params;
     let _ = debug_span!("Code actions JavaScript", range =? range, path =? path).entered();
     let tree = parse.tree();
@@ -1051,13 +1035,14 @@ pub(crate) fn code_actions(params: CodeActionsParams) -> PullActionsResult {
         range,
     };
 
-    let Some(source_type) = language.to_js_file_source() else {
+    let effective_services = snippet_services.unwrap_or(document_services);
+    let Some(source_type) = js_source_type_for_analysis(path, &language, effective_services) else {
         error!("Could not determine the file source of the file");
         return PullActionsResult {
             actions: Vec::new(),
         };
     };
-    let semantic_model = document_services
+    let semantic_model = effective_services
         .as_js_services()
         .and_then(|s| s.semantic_model.clone());
     let services =
@@ -1120,11 +1105,11 @@ pub(crate) fn fix_all(params: FixAllParams) -> Result<FixFileResult, WorkspaceEr
         range: None,
     };
 
-    let Some(file_source) = params
-        .document_file_source
-        .to_js_file_source()
-        .or(JsFileSource::try_from(params.biome_path.as_path()).ok())
-    else {
+    let Some(file_source) = js_source_type_for_analysis(
+        params.biome_path,
+        &params.document_file_source,
+        params.document_services,
+    ) else {
         return Err(extension_error(params.biome_path));
     };
 
@@ -1332,6 +1317,7 @@ pub(crate) fn pull_diagnostics_and_actions(
         plugins,
         diagnostic_offset,
         document_services,
+        snippet_services,
     } = params;
     let tree = parse.tree();
     let analyzer_options =
@@ -1351,13 +1337,14 @@ pub(crate) fn pull_diagnostics_and_actions(
         range: None,
     };
 
-    let Some(source_type) = language.to_js_file_source() else {
+    let effective_services = snippet_services.unwrap_or(document_services);
+    let Some(source_type) = js_source_type_for_analysis(path, &language, effective_services) else {
         error!("Could not determine the file source of the file");
         return PullDiagnosticsAndActionsResult {
             diagnostics: Vec::new(),
         };
     };
-    let semantic_model = document_services
+    let semantic_model = effective_services
         .as_js_services()
         .and_then(|s| s.semantic_model.clone());
     let services =
@@ -1377,13 +1364,14 @@ pub(crate) fn pull_diagnostics_and_actions(
 }
 
 fn rename(
-    _rome_path: &BiomePath,
+    path: &BiomePath,
     parse: AnyParse,
     symbol_at: TextSize,
     new_name: String,
 ) -> Result<RenameResult, WorkspaceError> {
     let root = parse.tree();
-    let model = semantic_model(&root, SemanticModelOptions::default());
+    let source_type = JsFileSource::try_from(path.as_path()).unwrap_or_default();
+    let model = semantic_model(&root, SemanticModelOptions::from(&source_type));
 
     if let Some(node) = parse
         .syntax()
@@ -1417,6 +1405,20 @@ fn rename(
     }
 }
 
+fn js_source_type_for_analysis(
+    path: &BiomePath,
+    language: &DocumentFileSource,
+    services: &DocumentServices,
+) -> Option<JsFileSource> {
+    // Prefer source type captured while parsing embedded snippets, then fall back to
+    // document-level source type, then infer from path as a last resort.
+    services
+        .as_js_services()
+        .and_then(|services| services.source_type)
+        .or_else(|| language.to_js_file_source())
+        .or_else(|| JsFileSource::try_from(path.as_path()).ok())
+}
+
 #[instrument(level = "debug", skip_all)]
 fn update_snippets(
     root: AnyParse,
diff --git a/crates/biome_service/src/file_handlers/json.rs b/crates/biome_service/src/file_handlers/json.rs
index 3601237322d1..9f4edadefb32 100644
--- a/crates/biome_service/src/file_handlers/json.rs
+++ b/crates/biome_service/src/file_handlers/json.rs
@@ -594,6 +594,7 @@ fn code_actions(params: CodeActionsParams) -> PullActionsResult {
         categories,
         action_offset,
         document_services: _,
+        snippet_services: _,
     } = params;
 
     let _ = debug_span!("Code actions JSON",  range =? range, path =? path).entered();
diff --git a/crates/biome_service/src/file_handlers/mod.rs b/crates/biome_service/src/file_handlers/mod.rs
index f7c4efb75972..c9400e72ea09 100644
--- a/crates/biome_service/src/file_handlers/mod.rs
+++ b/crates/biome_service/src/file_handlers/mod.rs
@@ -39,7 +39,7 @@ use biome_js_analyze::METADATA as js_metadata;
 use biome_js_parser::{JsParserOptions, parse};
 use biome_js_syntax::{
     AnyJsModuleItem, EmbeddingKind, JsFileSource, JsLanguage, JsxAttribute, JsxAttributeList,
-    Language, LanguageVariant, TextRange, TextSize,
+    Language, LanguageVariant, SvelteFileKind, TextRange, TextSize,
 };
 use biome_json_analyze::METADATA as json_metadata;
 use biome_json_syntax::{JsonFileSource, JsonLanguage};
@@ -615,6 +615,8 @@ pub(crate) struct DiagnosticsAndActionsParams<'a> {
     pub(crate) plugins: AnalyzerPluginVec,
     pub(crate) diagnostic_offset: Option<TextSize>,
     pub(crate) document_services: &'a DocumentServices,
+    // Services attached to the current embedded snippet, when diagnostics are run on snippets.
+    pub(crate) snippet_services: Option<&'a DocumentServices>,
 }
 
 pub(crate) struct LintResults {
@@ -979,6 +981,8 @@ pub(crate) struct CodeActionsParams<'a> {
     pub(crate) categories: RuleCategories,
     pub(crate) action_offset: Option<TextSize>,
     pub(crate) document_services: &'a DocumentServices,
+    // Services attached to the current embedded snippet, when actions are run on snippets.
+    pub(crate) snippet_services: Option<&'a DocumentServices>,
 }
 
 pub(crate) struct UpdateSnippetsNodes {
@@ -1123,14 +1127,23 @@ impl Features {
         }
     }
 
-    /// Returns the [Capabilities] associated with a [BiomePath]
+    /// Returns the [Capabilities] associated with a document source.
     pub(crate) fn get_capabilities(&self, language_hint: DocumentFileSource) -> Capabilities {
         match language_hint {
             // TODO: remove match once we remove vue/astro/svelte handlers
             DocumentFileSource::Js(source) => match source.as_embedding_kind() {
                 EmbeddingKind::Astro { .. } => self.astro.capabilities(),
                 EmbeddingKind::Vue { .. } => self.vue.capabilities(),
-                EmbeddingKind::Svelte { .. } => self.svelte.capabilities(),
+                // `.svelte.ts` / `.svelte.js` are full JS/TS modules with Svelte
+                // semantics; `.svelte` component documents still use the Svelte handler.
+                EmbeddingKind::Svelte {
+                    kind: SvelteFileKind::SourceModule,
+                    ..
+                } => self.js.capabilities(),
+                EmbeddingKind::Svelte {
+                    kind: SvelteFileKind::Component,
+                    ..
+                } => self.svelte.capabilities(),
                 EmbeddingKind::None => self.js.capabilities(),
             },
             DocumentFileSource::Json(_) => self.json.capabilities(),
@@ -2038,3 +2051,68 @@ impl<'b> AnalyzerVisitorBuilder<'b> {
         (enabled_rules, disabled_rules, analyzer_options)
     }
 }
+#[cfg(test)]
+mod tests {
+    use super::{DocumentFileSource, Features};
+    use camino::Utf8Path;
+
+    #[test]
+    fn markdown_file_source_detection_and_capabilities() {
+        let source = DocumentFileSource::from_path(Utf8Path::new("docs/readme.md"), false);
+        assert!(matches!(source, DocumentFileSource::Unknown));
+
+        let language_source = DocumentFileSource::from_language_id("markdown");
+        assert!(matches!(language_source, DocumentFileSource::Unknown));
+
+        assert!(!DocumentFileSource::can_parse(Utf8Path::new(
+            "docs/readme.md"
+        )));
+        assert!(!DocumentFileSource::can_read(Utf8Path::new(
+            "docs/readme.md"
+        )));
+        assert!(!DocumentFileSource::can_contain_embeds(
+            Utf8Path::new("docs/readme.md"),
+            false
+        ));
+    }
+
+    #[test]
+    fn markdown_features_provide_formatter_capabilities() {
+        let features = Features::new();
+        let path = Utf8Path::new("doc.md");
+        let capabilities = features.get_capabilities(DocumentFileSource::from_path(path, false));
+
+        assert!(capabilities.formatter.format.is_none());
+        assert!(capabilities.parser.parse.is_none());
+    }
+
+    #[test]
+    fn svelte_source_modules_use_js_capabilities() {
+        let features = Features::new();
+        let path = Utf8Path::new("file.svelte.js");
+        let capabilities = features.get_capabilities(DocumentFileSource::from_path(path, false));
+
+        assert!(capabilities.analyzer.rename.is_some());
+        assert!(capabilities.analyzer.pull_diagnostics_and_actions.is_some());
+    }
+
+    #[test]
+    fn svelte_typescript_source_modules_use_js_capabilities() {
+        let features = Features::new();
+        let path = Utf8Path::new("file.svelte.ts");
+        let capabilities = features.get_capabilities(DocumentFileSource::from_path(path, false));
+
+        assert!(capabilities.analyzer.rename.is_some());
+        assert!(capabilities.analyzer.pull_diagnostics_and_actions.is_some());
+    }
+
+    #[test]
+    fn svelte_component_files_keep_svelte_capabilities() {
+        let features = Features::new();
+        let path = Utf8Path::new("file.svelte");
+        let capabilities = features.get_capabilities(DocumentFileSource::from_path(path, false));
+
+        assert!(capabilities.analyzer.rename.is_none());
+        assert!(capabilities.analyzer.pull_diagnostics_and_actions.is_none());
+    }
+}
diff --git a/crates/biome_service/src/file_handlers/svelte.rs b/crates/biome_service/src/file_handlers/svelte.rs
index 44fdd8621d50..b82bbef6b743 100644
--- a/crates/biome_service/src/file_handlers/svelte.rs
+++ b/crates/biome_service/src/file_handlers/svelte.rs
@@ -12,7 +12,9 @@ use biome_fs::BiomePath;
 use biome_html_syntax::HtmlLanguage;
 use biome_js_formatter::format_node;
 use biome_js_parser::{JsParserOptions, parse_js_with_cache};
-use biome_js_syntax::{EmbeddingKind, JsFileSource, JsLanguage, TextRange, TextSize};
+use biome_js_syntax::{
+    EmbeddingKind, JsFileSource, JsLanguage, SvelteFileKind, TextRange, TextSize,
+};
 use biome_parser::AnyParse;
 use biome_rowan::NodeCache;
 use regex::{Match, Regex};
@@ -76,7 +78,10 @@ impl SvelteFileHandler {
                 Some(
                     JsFileSource::from(language)
                         .with_variant(variant)
-                        .with_embedding_kind(EmbeddingKind::Svelte { is_source: true }),
+                        .with_embedding_kind(EmbeddingKind::Svelte {
+                            is_source: true,
+                            kind: SvelteFileKind::Component,
+                        }),
                 )
             })
             .map_or(JsFileSource::js_module(), |fs| fs)
@@ -126,21 +131,33 @@ impl ExtensionHandler for SvelteFileHandler {
 
 fn parse(
     _rome_path: &BiomePath,
-    _file_source: DocumentFileSource,
+    file_source: DocumentFileSource,
     text: &str,
     _settings: &SettingsWithEditor,
     cache: &mut NodeCache,
 ) -> ParseResult {
-    let script = SvelteFileHandler::input(text);
-    let file_source = SvelteFileHandler::file_source(text);
+    let source_type = file_source.to_js_file_source().unwrap_or_default();
+    let (script, script_file_source) = if source_type.is_svelte_source_module() {
+        (text, source_type)
+    } else {
+        (
+            SvelteFileHandler::input(text),
+            SvelteFileHandler::file_source(text),
+        )
+    };
 
-    debug!("Parsing file with language {:?}", file_source);
+    debug!("Parsing file with language {:?}", script_file_source);
 
-    let parse = parse_js_with_cache(script, file_source, JsParserOptions::default(), cache);
+    let parse = parse_js_with_cache(
+        script,
+        script_file_source,
+        JsParserOptions::default(),
+        cache,
+    );
 
     ParseResult {
         any_parse: parse.into(),
-        language: Some(file_source.into()),
+        language: Some(file_source),
     }
 }
 
diff --git a/crates/biome_service/src/workspace/document/mod.rs b/crates/biome_service/src/workspace/document/mod.rs
index 3cc95817ac9a..8b5bb4b408b7 100644
--- a/crates/biome_service/src/workspace/document/mod.rs
+++ b/crates/biome_service/src/workspace/document/mod.rs
@@ -10,7 +10,7 @@ use biome_css_syntax::{AnyCssRoot, CssLanguage};
 use biome_diagnostics::Error;
 use biome_diagnostics::serde::Diagnostic as SerdeDiagnostic;
 use biome_js_semantic::SemanticModelOptions;
-use biome_js_syntax::{AnyJsRoot, JsLanguage};
+use biome_js_syntax::{AnyJsRoot, JsFileSource, JsLanguage};
 use biome_json_syntax::JsonLanguage;
 use biome_parser::AnyParse;
 use biome_rowan::{AstNode, SyntaxNodeWithOffset, TextRange, TextSize};
@@ -373,14 +373,33 @@ impl CssDocumentServices {
 pub struct JsDocumentServices {
     /// Semantic model that belongs to the file
     pub(crate) semantic_model: Option<biome_js_semantic::SemanticModel>,
+    /// Source type used to build the semantic model.
+    pub(crate) source_type: Option<JsFileSource>,
 }
 
 impl JsDocumentServices {
-    pub fn with_js_semantic_model(mut self, root: &AnyJsRoot) -> Self {
+    pub fn with_js_semantic_model(mut self, root: &AnyJsRoot, source_type: &JsFileSource) -> Self {
         self.semantic_model = Some(biome_js_semantic::semantic_model(
             root,
-            SemanticModelOptions::default(),
+            SemanticModelOptions::from(source_type),
         ));
+        self.source_type = Some(*source_type);
         self
     }
+
+    /// Builds document services for a JS snippet and includes semantic data only
+    /// when analyzer-backed features are enabled.
+    pub fn from_js_snippet(
+        root: &AnyJsRoot,
+        source_type: &JsFileSource,
+        is_analyzer_enabled: bool,
+    ) -> DocumentServices {
+        if is_analyzer_enabled {
+            Self::default()
+                .with_js_semantic_model(root, source_type)
+                .into()
+        } else {
+            DocumentServices::none()
+        }
+    }
 }
diff --git a/crates/biome_service/src/workspace/server.rs b/crates/biome_service/src/workspace/server.rs
index 6097ae658098..34fe8e6b13ba 100644
--- a/crates/biome_service/src/workspace/server.rs
+++ b/crates/biome_service/src/workspace/server.rs
@@ -2,6 +2,7 @@ use super::{document::Document, *};
 use crate::Watcher;
 use crate::configuration::{LoadedConfiguration, ProjectScanComputer, read_config};
 use crate::diagnostics::{FileTooLarge, NoIgnoreFileFound, VcsDiagnostic};
+use crate::file_handlers::svelte::SvelteFileHandler;
 use crate::file_handlers::{
     Capabilities, CodeActionsParams, DiagnosticsAndActionsParams, DocumentFileSource, Features,
     FixAllParams, FormatEmbedNode, LintParams, LintResults, ParseResult, UpdateSnippetsNodes,
@@ -49,7 +50,7 @@ use biome_formatter::Printed;
 use biome_fs::{BiomePath, ConfigName, PathKind, normalize_path};
 use biome_grit_patterns::{CompilePatternOptions, GritQuery, compile_pattern_with_options};
 use biome_html_syntax::HtmlRoot;
-use biome_js_syntax::{AnyJsRoot, LanguageVariant, ModuleKind};
+use biome_js_syntax::{AnyJsRoot, EmbeddingKind, LanguageVariant, ModuleKind};
 use biome_json_parser::JsonParserOptions;
 use biome_json_syntax::JsonFileSource;
 use biome_module_graph::{ModuleDependencies, ModuleDiagnostic, ModuleGraph};
@@ -170,6 +171,21 @@ impl WorkspaceServer {
         SettingsHandle::new(settings, editor)
     }
 
+    /// LSP language ids cover broad languages (`javascript`, `typescript`) but
+    /// not path-specific framework variants like `.svelte.ts`.
+    fn should_prefer_path_source(
+        document_file_source: DocumentFileSource,
+        path_source: DocumentFileSource,
+    ) -> bool {
+        match (document_file_source, path_source) {
+            (DocumentFileSource::Js(_), DocumentFileSource::Html(_)) => true,
+            (DocumentFileSource::Js(_), DocumentFileSource::Js(path_source)) => {
+                !matches!(path_source.as_embedding_kind(), EmbeddingKind::None)
+            }
+            _ => false,
+        }
+    }
+
     /// Starts the watcher.
     ///
     /// This method will not return until the watcher stops.
@@ -333,16 +349,16 @@ impl WorkspaceServer {
             .ok_or_else(WorkspaceError::no_project)?;
 
         let mut source = if let Some(document_file_source) = document_file_source {
-            // TODO: remove once HTML full support is stable
-            // document_file_source is given by the LSP, and we have to change it if full support is enabled.
-            // The workspace knows that, but the LSP doesn't, so we have to do the modification here
-            if document_file_source.is_javascript_like()
-                && matches!(path.extension(), Some("astro" | "vue" | "svelte" | "html"))
-            {
-                DocumentFileSource::from_path(
-                    &path,
-                    settings.experimental_full_html_support_enabled(),
-                )
+            let path_source = DocumentFileSource::from_path(
+                &path,
+                settings.experimental_full_html_support_enabled(),
+            );
+            // LSP language ids cannot encode path-specific framework variants like
+            // `.svelte.ts` / `.svelte.js`, and HTML full support can also upgrade
+            // JS-like hints to HTML. Prefer the path-derived source only when it
+            // carries richer semantics than the editor-provided JS hint.
+            if Self::should_prefer_path_source(document_file_source, path_source) {
+                path_source
             } else {
                 document_file_source
             }
@@ -443,9 +459,16 @@ impl WorkspaceServer {
                         services = CssDocumentServices::default()
                             .with_css_semantic_model(&any_parse.tree())
                             .into();
-                    } else if language.is_javascript_like() {
+                    } else if let DocumentFileSource::Js(source_type) = language {
+                        let source_type = if source_type.is_svelte_component() {
+                            // Component files infer JS/TS from `<script ...>` content.
+                            // Source modules (`.svelte.ts` / `.svelte.js`) already carry source type.
+                            SvelteFileHandler::file_source(&content)
+                        } else {
+                            source_type
+                        };
                         services = JsDocumentServices::default()
-                            .with_js_semantic_model(&any_parse.tree())
+                            .with_js_semantic_model(&any_parse.tree(), &source_type)
                             .into();
                     }
                 }
@@ -1615,9 +1638,16 @@ impl Workspace for WorkspaceServer {
                 services = CssDocumentServices::default()
                     .with_css_semantic_model(&parsed.any_parse.tree())
                     .into();
-            } else if document_source.is_javascript_like() {
+            } else if let DocumentFileSource::Js(source_type) = document_source {
+                let source_type = if source_type.is_svelte_component() {
+                    // Component files infer JS/TS from `<script ...>` content.
+                    // Source modules (`.svelte.ts` / `.svelte.js`) already carry source type.
+                    SvelteFileHandler::file_source(&content)
+                } else {
+                    source_type
+                };
                 services = JsDocumentServices::default()
-                    .with_js_semantic_model(&parsed.any_parse.tree())
+                    .with_js_semantic_model(&parsed.any_parse.tree(), &source_type)
                     .into();
             }
         }
@@ -1825,8 +1855,8 @@ impl Workspace for WorkspaceServer {
                 .filter(|diag| diag.severity() <= Severity::Error)
                 .count();
 
-            for embedded_node in embedded_snippets {
-                let diagnostics = embedded_node.into_serde_diagnostics();
+            for embedded_node in &embedded_snippets {
+                let diagnostics = embedded_node.clone().into_serde_diagnostics();
                 errors += diagnostics
                     .iter()
                     .filter(|diag| diag.severity() <= Severity::Error)
@@ -1907,9 +1937,10 @@ impl Workspace for WorkspaceServer {
                 plugins: plugins.clone(),
                 diagnostic_offset: None,
                 document_services: &services,
+                snippet_services: None,
             });
 
-            for embedded_node in embedded_snippets {
+            for embedded_node in &embedded_snippets {
                 let Some(file_source) = self.get_source(embedded_node.file_source_index()) else {
                     continue;
                 };
@@ -1921,7 +1952,7 @@ impl Workspace for WorkspaceServer {
                 };
 
                 let snippet_result = pull_diagnostics_and_actions(DiagnosticsAndActionsParams {
-                    parse: embedded_node.parse().clone(),
+                    parse: embedded_node.parse(),
                     settings: &handle,
                     path: &path,
                     only: &only,
@@ -1935,6 +1966,7 @@ impl Workspace for WorkspaceServer {
                     plugins: plugins.clone(),
                     diagnostic_offset: Some(embedded_node.content_offset()),
                     document_services: &services,
+                    snippet_services: Some(embedded_node.as_snippet_services()),
                 });
 
                 final_result.diagnostics.extend(snippet_result.diagnostics);
@@ -2007,9 +2039,10 @@ impl Workspace for WorkspaceServer {
             categories,
             action_offset: None,
             document_services: &services,
+            snippet_services: None,
         });
 
-        for embedded_snippet in embedded_snippets {
+        for embedded_snippet in &embedded_snippets {
             let Some(file_source) = self.get_source(embedded_snippet.file_source_index()) else {
                 continue;
             };
@@ -2034,6 +2067,7 @@ impl Workspace for WorkspaceServer {
                 categories,
                 action_offset: Some(embedded_snippet.content_offset()),
                 document_services: &services,
+                snippet_services: Some(embedded_snippet.as_snippet_services()),
             });
 
             result.actions.extend(embedded_actions_result.actions);
diff --git a/crates/biome_service/src/workspace/server.tests.rs b/crates/biome_service/src/workspace/server.tests.rs
index eeb22c4e6ac6..6e440985172f 100644
--- a/crates/biome_service/src/workspace/server.tests.rs
+++ b/crates/biome_service/src/workspace/server.tests.rs
@@ -785,3 +785,53 @@ const highlight = foo`some tagged template` // unknown tagged template
 
     insta::assert_snapshot!(result.as_code());
 }
+
+#[test]
+fn lsp_language_hints_keep_svelte_source_module_path_semantics() {
+    const SVELTE_TS_FILE_PATH: &str = "/project/component.svelte.ts";
+    const SVELTE_JS_FILE_PATH: &str = "/project/component.svelte.js";
+
+    let fs = MemoryFileSystem::default();
+    fs.insert(
+        Utf8PathBuf::from(SVELTE_TS_FILE_PATH),
+        b"export const count = 1;",
+    );
+    fs.insert(
+        Utf8PathBuf::from(SVELTE_JS_FILE_PATH),
+        b"export const count = 1;",
+    );
+
+    let (workspace, project_key) = setup_workspace_and_open_project(fs, "/");
+
+    workspace
+        .open_file(OpenFileParams {
+            project_key,
+            path: BiomePath::new(SVELTE_TS_FILE_PATH),
+            content: FileContent::FromServer,
+            document_file_source: Some(DocumentFileSource::from_language_id("typescript")),
+            persist_node_cache: false,
+            inline_config: None,
+        })
+        .unwrap();
+
+    workspace
+        .open_file(OpenFileParams {
+            project_key,
+            path: BiomePath::new(SVELTE_JS_FILE_PATH),
+            content: FileContent::FromServer,
+            document_file_source: Some(DocumentFileSource::from_language_id("javascript")),
+            persist_node_cache: false,
+            inline_config: None,
+        })
+        .unwrap();
+
+    let ts_file_source = workspace.get_file_source(SVELTE_TS_FILE_PATH.into(), false);
+    let ts = ts_file_source.to_js_file_source().expect("JS file source");
+    assert!(ts.is_svelte_source_module());
+    assert!(ts.is_typescript());
+
+    let js_file_source = workspace.get_file_source(SVELTE_JS_FILE_PATH.into(), false);
+    let js = js_file_source.to_js_file_source().expect("JS file source");
+    assert!(js.is_svelte_source_module());
+    assert!(!js.is_typescript());
+}
diff --git a/packages/@biomejs/backend-jsonrpc/src/workspace.ts b/packages/@biomejs/backend-jsonrpc/src/workspace.ts
index df4045b870e8..62ce1850b84a 100644
--- a/packages/@biomejs/backend-jsonrpc/src/workspace.ts
+++ b/packages/@biomejs/backend-jsonrpc/src/workspace.ts
@@ -9151,6 +9151,13 @@ Source-level embeds (`<script>`) use `true`; directives and text expressions use
 				 * Where the bindings are defined
 				 */
 				is_source: boolean;
+				/**
+	* `kind` models whether the Svelte file is a component document or a
+source module. That distinction controls whether downstream code
+extracts `<script>` content or treats the file as a standalone JS/TS
+module, while `is_source` still tracks where bindings come from. 
+	 */
+				kind: SvelteFileKind;
 			};
 	  };
 export type Language =
@@ -9198,6 +9205,7 @@ export type HtmlVariant =
 	| "Svelte";
 export type GritVariant = "Standard";
 export type MarkdownVariant = "Standard";
+export type SvelteFileKind = "Component" | "SourceModule";
 export type EmbeddingHtmlKind = "None" | "Html" | "Vue" | "Astro" | "Svelte";
 export type HtmlTextExpressions = "None" | "Single" | "Double";
 export interface OpenFileResult {