rbtr-lang-svelte 2026.9.0.dev1__tar.gz

rbtr_lang_svelte-2026.9.0.dev1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Alejandro Giacometti
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

rbtr_lang_svelte-2026.9.0.dev1/PKG-INFO

@@ -0,0 +1,78 @@
+Metadata-Version: 2.4
+Name: rbtr-lang-svelte
+Version: 2026.9.0.dev1
+Summary: rbtr — Svelte language plugin (and shared SFC machinery)
+Keywords: code-search,code-index,tree-sitter,static-analysis,semantic-search,developer-tools,svelte
+Author: Alejandro Giacometti
+Author-email: Alejandro Giacometti <alejandro.giacometti@gmail.com>
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: Text Processing :: Indexing
+Classifier: Typing :: Typed
+Requires-Dist: rbtr==2026.9.0.dev1
+Requires-Dist: tree-sitter-svelte
+Requires-Python: >=3.13
+Project-URL: Homepage, https://github.com/janrito/rbtr
+Project-URL: Repository, https://github.com/janrito/rbtr
+Project-URL: Documentation, https://github.com/janrito/rbtr/tree/main/packages/rbtr-lang-svelte#readme
+Project-URL: Issues, https://github.com/janrito/rbtr/issues
+Project-URL: Changelog, https://github.com/janrito/rbtr/releases
+Description-Content-Type: text/markdown
+
+# rbtr-lang-svelte
+
+Svelte support for [rbtr]. Optional plugin — install with
+`pip install rbtr[svelte]`. Also hosts the shared single-file-component
+machinery that [rbtr-lang-vue] reuses.
+
+[rbtr]: https://github.com/janrito/rbtr/tree/main/packages/rbtr#readme
+[rbtr-lang-vue]: https://github.com/janrito/rbtr/tree/main/packages/rbtr-lang-vue#readme
+
+## What it ingests
+
+`.svelte` components. A component mixes several languages in one file, and
+each part is indexed as itself:
+
+- The **markup template** becomes one host **doc-section** chunk (named after
+  the file), so component markup is searchable.
+- A **comment** above the markup is its own chunk, so the note explaining
+  what the component is for stays searchable.
+- The `<script>` and `<style>` blocks are **delegated** to their embedded
+  language by injection (see below) — not re-parsed here.
+
+## Chunks produced
+
+```svelte
+<script lang="ts">
+  import { store } from "./store";     // → import        (typescript)
+  export let name = "world";           // → variable "name" (typescript)
+</script>
+
+<h1 class="greeting">Hello {name}</h1> <!-- → doc_section "Greeting" (svelte host) -->
+
+<style lang="scss">
+  .greeting { color: red; }            // → class ".greeting" (scss)
+</style>
+```
+
+## Embedded / injected chunks
+
+The `lang` attribute picks the dialect; a bare block uses the fallback:
+
+- `<script lang="ts">` → **TypeScript**, bare `<script>` → **JavaScript**
+- `<style lang="scss">` → **SCSS**, `lang="less"` → **Less**, bare `<style>`
+  → **CSS**
+
+These chunks carry their *embedded* language; the delegated extraction runs
+only when the corresponding plugin (e.g. `rbtr-lang-javascript`,
+`rbtr-lang-css`) is installed.
+
+## Grammar & dependencies
+
+Uses the `tree-sitter-svelte` grammar. Ships `chunk_sfc` and `injections.scm`,
+which `rbtr-lang-vue` imports for `.vue` files (they share the SFC shape).

rbtr_lang_svelte-2026.9.0.dev1/README.md

@@ -0,0 +1,52 @@
+# rbtr-lang-svelte
+
+Svelte support for [rbtr]. Optional plugin — install with
+`pip install rbtr[svelte]`. Also hosts the shared single-file-component
+machinery that [rbtr-lang-vue] reuses.
+
+[rbtr]: https://github.com/janrito/rbtr/tree/main/packages/rbtr#readme
+[rbtr-lang-vue]: https://github.com/janrito/rbtr/tree/main/packages/rbtr-lang-vue#readme
+
+## What it ingests
+
+`.svelte` components. A component mixes several languages in one file, and
+each part is indexed as itself:
+
+- The **markup template** becomes one host **doc-section** chunk (named after
+  the file), so component markup is searchable.
+- A **comment** above the markup is its own chunk, so the note explaining
+  what the component is for stays searchable.
+- The `<script>` and `<style>` blocks are **delegated** to their embedded
+  language by injection (see below) — not re-parsed here.
+
+## Chunks produced
+
+```svelte
+<script lang="ts">
+  import { store } from "./store";     // → import        (typescript)
+  export let name = "world";           // → variable "name" (typescript)
+</script>
+
+<h1 class="greeting">Hello {name}</h1> <!-- → doc_section "Greeting" (svelte host) -->
+
+<style lang="scss">
+  .greeting { color: red; }            // → class ".greeting" (scss)
+</style>
+```
+
+## Embedded / injected chunks
+
+The `lang` attribute picks the dialect; a bare block uses the fallback:
+
+- `<script lang="ts">` → **TypeScript**, bare `<script>` → **JavaScript**
+- `<style lang="scss">` → **SCSS**, `lang="less"` → **Less**, bare `<style>`
+  → **CSS**
+
+These chunks carry their *embedded* language; the delegated extraction runs
+only when the corresponding plugin (e.g. `rbtr-lang-javascript`,
+`rbtr-lang-css`) is installed.
+
+## Grammar & dependencies
+
+Uses the `tree-sitter-svelte` grammar. Ships `chunk_sfc` and `injections.scm`,
+which `rbtr-lang-vue` imports for `.vue` files (they share the SFC shape).

rbtr_lang_svelte-2026.9.0.dev1/pyproject.toml

@@ -0,0 +1,67 @@
+[build-system]
+requires = ["uv_build>=0.11.26,<1"]
+build-backend = "uv_build"
+
+[tool.uv.build-backend]
+module-name = "rbtr_lang_svelte"
+
+[tool.uv.sources.rbtr]
+workspace = true
+
+[tool.uv.sources.rbtr-lang-javascript]
+workspace = true
+
+[tool.uv.sources.rbtr-lang-scss]
+workspace = true
+
+[project]
+name = "rbtr-lang-svelte"
+version = "2026.9.0-dev1"
+description = "rbtr — Svelte language plugin (and shared SFC machinery)"
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"]
+keywords = [
+    "code-search",
+    "code-index",
+    "tree-sitter",
+    "static-analysis",
+    "semantic-search",
+    "developer-tools",
+    "svelte",
+]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "Programming Language :: Python :: 3 :: Only",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Software Development :: Libraries",
+    "Topic :: Text Processing :: Indexing",
+    "Typing :: Typed",
+]
+requires-python = ">=3.13"
+dependencies = [
+    "rbtr==2026.9.0-dev1",
+    "tree-sitter-svelte",
+]
+
+[[project.authors]]
+name = "Alejandro Giacometti"
+email = "alejandro.giacometti@gmail.com"
+
+[project.urls]
+Homepage = "https://github.com/janrito/rbtr"
+Repository = "https://github.com/janrito/rbtr"
+Documentation = "https://github.com/janrito/rbtr/tree/main/packages/rbtr-lang-svelte#readme"
+Issues = "https://github.com/janrito/rbtr/issues"
+Changelog = "https://github.com/janrito/rbtr/releases"
+
+[project.entry-points."rbtr.languages"]
+svelte = "rbtr_lang_svelte.plugin:svelte"
+
+[dependency-groups]
+dev = [
+    "rbtr[test]",
+    "rbtr-lang-javascript",
+    "rbtr-lang-scss",
+]

rbtr_lang_svelte-2026.9.0.dev1/pyproject.toml.orig

@@ -0,0 +1,64 @@
+[build-system]
+requires = ["uv_build>=0.11.26,<1"]
+build-backend = "uv_build"
+
+[tool.uv.build-backend]
+module-name = "rbtr_lang_svelte"
+# No source-exclude: the plugin's tests, samples, and snapshots ship with
+# the wheel (they are the language's golden record), and injections.scm ships
+# as package data (reused by rbtr-lang-vue).
+
+[project]
+name = "rbtr-lang-svelte"
+version = "2026.9.0-dev1"
+description = "rbtr — Svelte language plugin (and shared SFC machinery)"
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [
+  { name = "Alejandro Giacometti", email = "alejandro.giacometti@gmail.com" },
+]
+keywords = [
+  "code-search",
+  "code-index",
+  "tree-sitter",
+  "static-analysis",
+  "semantic-search",
+  "developer-tools",
+  "svelte",
+]
+classifiers = [
+  "Development Status :: 4 - Beta",
+  "Intended Audience :: Developers",
+  "Programming Language :: Python :: 3 :: Only",
+  "Programming Language :: Python :: 3.13",
+  "Topic :: Software Development :: Libraries",
+  "Topic :: Text Processing :: Indexing",
+  "Typing :: Typed",
+]
+requires-python = ">=3.13"
+dependencies = [
+  "rbtr==2026.9.0-dev1",
+  "tree-sitter-svelte",
+]
+
+[project.urls]
+Homepage = "https://github.com/janrito/rbtr"
+Repository = "https://github.com/janrito/rbtr"
+Documentation = "https://github.com/janrito/rbtr/tree/main/packages/rbtr-lang-svelte#readme"
+Issues = "https://github.com/janrito/rbtr/issues"
+Changelog = "https://github.com/janrito/rbtr/releases"
+
+[project.entry-points."rbtr.languages"]
+# The value resolves to the language's `LanguageRegistration` (named by its
+# id) — see the rbtr ARCHITECTURE "External plugins" note.
+svelte = "rbtr_lang_svelte.plugin:svelte"
+
+[tool.uv.sources]
+rbtr = { workspace = true }
+rbtr-lang-javascript = { workspace = true }
+rbtr-lang-scss = { workspace = true }
+
+[dependency-groups]
+# The sample embeds lang="ts" and lang="scss" blocks (scss pulls css).
+dev = ["rbtr[test]", "rbtr-lang-javascript", "rbtr-lang-scss"]

rbtr_lang_svelte-2026.9.0.dev1/src/rbtr_lang_svelte/__init__.py

@@ -0,0 +1 @@
+"""Single-file component (Svelte, Vue) language plugin package."""

rbtr_lang_svelte-2026.9.0.dev1/src/rbtr_lang_svelte/injections.scm

@@ -0,0 +1,41 @@
+; <script>/<style> blocks delegate to JS/TS/CSS/SCSS/Less. A `lang="…"`
+; attribute selects the dialect (priority 1); the bare block is the
+; fallback (priority 0).
+
+((script_element
+   (start_tag
+     (attribute (attribute_name) @_attr
+       (quoted_attribute_value (attribute_value) @_lang)))
+   (raw_text) @injection.content)
+ (#eq? @_attr "lang")
+ (#any-of? @_lang "ts" "typescript")
+ (#set! injection.language "typescript")
+ (#set! injection.priority "1"))
+
+((script_element (raw_text) @injection.content)
+ (#set! injection.language "javascript")
+ (#set! injection.priority "0"))
+
+((style_element
+   (start_tag
+     (attribute (attribute_name) @_attr
+       (quoted_attribute_value (attribute_value) @_lang)))
+   (raw_text) @injection.content)
+ (#eq? @_attr "lang")
+ (#any-of? @_lang "scss" "sass")
+ (#set! injection.language "scss")
+ (#set! injection.priority "1"))
+
+((style_element
+   (start_tag
+     (attribute (attribute_name) @_attr
+       (quoted_attribute_value (attribute_value) @_lang)))
+   (raw_text) @injection.content)
+ (#eq? @_attr "lang")
+ (#any-of? @_lang "less")
+ (#set! injection.language "less")
+ (#set! injection.priority "1"))
+
+((style_element (raw_text) @injection.content)
+ (#set! injection.language "css")
+ (#set! injection.priority "0"))

rbtr_lang_svelte-2026.9.0.dev1/src/rbtr_lang_svelte/plugin.py

@@ -0,0 +1,121 @@
+"""Svelte plugin, plus the single-file-component (SFC) machinery shared with Vue.
+
+A Svelte (or Vue) component embeds code in several languages in one
+file: a `<script>` block (JavaScript/TypeScript), a `<style>`
+block (CSS/SCSS/Less), and a markup template. The `<script>` and
+`<style>` blocks are delegated to their embedded language by the
+engine's injection mechanism (`injection_query`); the chunker emits
+only the markup template, as a host chunk so component markup is
+searchable.
+
+The template chunk's `language` is left blank for the orchestrator
+to fill with the host language (svelte/vue); delegated chunks carry
+their embedded language, set by the target's extractor.
+
+`chunk_sfc` and `injections.scm` are shared: the `rbtr-lang-vue`
+package reuses both for `.vue` files, which expose the same
+`<script>`/`<style>` shape.
+"""
+
+from __future__ import annotations
+
+from pathlib import PurePosixPath
+from typing import TYPE_CHECKING
+
+from tree_sitter import Parser
+
+from rbtr.domain.models import Chunk, ChunkKind
+from rbtr.languages.chunks import last_line
+from rbtr.languages.registration import LanguageRegistration, load_query
+
+if TYPE_CHECKING:
+    from collections.abc import Iterator
+
+    from tree_sitter import Language, Node, Range
+
+
+def _template_chunk(
+    file_path: str, blob_sha: str, content_bytes: bytes, nodes: list[Node]
+) -> Chunk | None:
+    """Emit the markup template as one host-language chunk, or `None`.
+
+    Returns `None` when the component has no template markup (a script-only
+    component); the orchestrator records the host language for dedup in that
+    case. `language` is left blank for the orchestrator to fill (svelte/vue);
+    spans the markup nodes.
+    """
+    if not nodes:
+        return None
+    start = min(n.start_byte for n in nodes)
+    end = max(n.end_byte for n in nodes)
+    text = content_bytes[start:end].decode("utf-8", errors="replace").strip()
+    if not text:
+        return None
+    name = PurePosixPath(file_path).stem
+    line_start = min(n.start_point[0] for n in nodes)
+    line_end = max(last_line(n) for n in nodes)
+    return Chunk(
+        blob_sha=blob_sha,
+        file_path=file_path,
+        kind=ChunkKind.DOC_SECTION,
+        name=name,
+        scope="",
+        content=text,
+        line_start=line_start + 1,
+        line_end=line_end,
+    )
+
+
+def chunk_sfc(
+    file_path: str,
+    blob_sha: str,
+    content: str,
+    grammar: Language,
+    ranges: list[Range] | None = None,
+) -> Iterator[Chunk]:
+    """Emit the SFC's markup template, and any comment above it.
+
+    The `<script>`/`<style>` blocks are handled by the engine's injection
+    mechanism (`_SFC_INJECTIONS`), not here. A top-level comment is not
+    markup, so it does not belong to the template chunk; it is content
+    someone searches for, so it gets a chunk of its own.
+    """
+    content_bytes = content.encode("utf-8")
+    parser = Parser(grammar)
+    if ranges is not None:
+        parser.included_ranges = ranges
+    tree = parser.parse(content_bytes)
+    template_nodes = [
+        el
+        for el in tree.root_node.children
+        if el.type not in ("script_element", "style_element", "comment")
+    ]
+    template = _template_chunk(file_path, blob_sha, content_bytes, template_nodes)
+    if template is not None:
+        yield template
+
+    for node in tree.root_node.children:
+        if node.type != "comment":
+            continue
+        text = content_bytes[node.start_byte : node.end_byte].decode("utf-8", errors="replace")
+        yield Chunk(
+            blob_sha=blob_sha,
+            file_path=file_path,
+            kind=ChunkKind.COMMENT,
+            name="",
+            scope="",
+            content=text.strip(),
+            line_start=node.start_point[0] + 1,
+            line_end=last_line(node),
+        )
+
+
+svelte = LanguageRegistration(
+    id="svelte",
+    extensions=frozenset({".svelte"}),
+    grammar_module="tree_sitter_svelte",
+    injection_query=load_query(__package__, "injections"),
+    extraction_serial=3,
+)
+
+svelte.chunker(chunk_sfc)

rbtr_lang_svelte-2026.9.0.dev1/src/rbtr_lang_svelte/tests/__snapshots__/test_samples/test_edges_match_snapshot.json

@@ -0,0 +1,3 @@
+[
+  "Greeting.svelte::import { greet } from \"./greeter\"; -> greeter.ts::greet [imports]"
+]

rbtr_lang_svelte-2026.9.0.dev1/src/rbtr_lang_svelte/tests/__snapshots__/test_samples/test_extraction_matches_snapshot.json

@@ -0,0 +1,173 @@
+[
+  {
+    "blob_sha": "sha1",
+    "file_path": "Greeting.svelte",
+    "kind": "doc_section",
+    "name": "Greeting",
+    "scope": "",
+    "language": "svelte",
+    "file_language": "svelte",
+    "content": "<h1 class=\"greeting\">{shout()}</h1>",
+    "line_start": 28,
+    "line_end": 28,
+    "metadata": {
+      "module": "",
+      "names": "",
+      "dots": "",
+      "language_hint": ""
+    },
+    "id": "d9707b44a8167bb9"
+  },
+  {
+    "blob_sha": "sha1",
+    "file_path": "Greeting.svelte",
+    "kind": "comment",
+    "name": "",
+    "scope": "",
+    "language": "svelte",
+    "file_language": "svelte",
+    "content": "<!--\n  Svelte single-file component.\n\n  The SFC plugin delegates the <script> block to TypeScript and the\n  <style> block to SCSS; their symbols carry those languages and their\n  imports resolve through the matching resolver. The markup template is\n  not extracted.\n-->",
+    "line_start": 1,
+    "line_end": 8,
+    "metadata": {
+      "module": "",
+      "names": "",
+      "dots": "",
+      "language_hint": ""
+    },
+    "id": "5f2bbd1d04760dc6"
+  },
+  {
+    "blob_sha": "sha1",
+    "file_path": "Greeting.svelte",
+    "kind": "import",
+    "name": "import { greet } from \"./greeter\";",
+    "scope": "",
+    "language": "typescript",
+    "file_language": "svelte",
+    "content": "import { greet } from \"./greeter\";",
+    "line_start": 10,
+    "line_end": 10,
+    "metadata": {
+      "module": "greeter",
+      "names": "greet",
+      "dots": "1",
+      "language_hint": ""
+    },
+    "id": "9e08409ab07d56f2"
+  },
+  {
+    "blob_sha": "sha1",
+    "file_path": "Greeting.svelte",
+    "kind": "variable",
+    "name": "name",
+    "scope": "",
+    "language": "typescript",
+    "file_language": "svelte",
+    "content": "name: string = \"world\"",
+    "line_start": 12,
+    "line_end": 12,
+    "metadata": {
+      "module": "",
+      "names": "",
+      "dots": "",
+      "language_hint": ""
+    },
+    "id": "030615b8d1bfaaf0"
+  },
+  {
+    "blob_sha": "sha1",
+    "file_path": "Greeting.svelte",
+    "kind": "function",
+    "name": "shout",
+    "scope": "",
+    "language": "typescript",
+    "file_language": "svelte",
+    "content": "function shout(): string {\n    return greet(name).toUpperCase();\n  }",
+    "line_start": 14,
+    "line_end": 16,
+    "metadata": {
+      "module": "",
+      "names": "",
+      "dots": "",
+      "language_hint": ""
+    },
+    "id": "ca91fc7dc3b14adc"
+  },
+  {
+    "blob_sha": "sha1",
+    "file_path": "Greeting.svelte",
+    "kind": "variable",
+    "name": "$accent",
+    "scope": "",
+    "language": "scss",
+    "file_language": "svelte",
+    "content": "$accent: #00aa77;",
+    "line_start": 20,
+    "line_end": 20,
+    "metadata": {
+      "module": "",
+      "names": "",
+      "dots": "",
+      "language_hint": ""
+    },
+    "id": "83127d65b9be4d63"
+  },
+  {
+    "blob_sha": "sha1",
+    "file_path": "Greeting.svelte",
+    "kind": "class",
+    "name": ".greeting",
+    "scope": "",
+    "language": "scss",
+    "file_language": "svelte",
+    "content": ".greeting {\n    color: $accent;\n    font-weight: bold;\n  }",
+    "line_start": 22,
+    "line_end": 25,
+    "metadata": {
+      "module": "",
+      "names": "",
+      "dots": "",
+      "language_hint": ""
+    },
+    "id": "d263e499d49e38f4"
+  },
+  {
+    "blob_sha": "sha1",
+    "file_path": "greeter.ts",
+    "kind": "comment",
+    "name": "",
+    "scope": "",
+    "language": "typescript",
+    "file_language": "typescript",
+    "content": "// Imported by Greeting.svelte's <script> block.",
+    "line_start": 1,
+    "line_end": 1,
+    "metadata": {
+      "module": "",
+      "names": "",
+      "dots": "",
+      "language_hint": ""
+    },
+    "id": "b0eec444d8e60c22"
+  },
+  {
+    "blob_sha": "sha1",
+    "file_path": "greeter.ts",
+    "kind": "function",
+    "name": "greet",
+    "scope": "",
+    "language": "typescript",
+    "file_language": "typescript",
+    "content": "function greet(name: string): string {\n  return `Hello, ${name}`;\n}",
+    "line_start": 3,
+    "line_end": 5,
+    "metadata": {
+      "module": "",
+      "names": "",
+      "dots": "",
+      "language_hint": ""
+    },
+    "id": "babbec3806fb9d96"
+  }
+]

rbtr_lang_svelte-2026.9.0.dev1/src/rbtr_lang_svelte/tests/samples/svelte/Greeting.svelte

@@ -0,0 +1,28 @@
+<!--
+  Svelte single-file component.
+
+  The SFC plugin delegates the <script> block to TypeScript and the
+  <style> block to SCSS; their symbols carry those languages and their
+  imports resolve through the matching resolver. The markup template is
+  not extracted.
+-->
+<script lang="ts">
+  import { greet } from "./greeter";
+
+  export let name: string = "world";
+
+  function shout(): string {
+    return greet(name).toUpperCase();
+  }
+</script>
+
+<style lang="scss">
+  $accent: #00aa77;
+
+  .greeting {
+    color: $accent;
+    font-weight: bold;
+  }
+</style>
+
+<h1 class="greeting">{shout()}</h1>

rbtr_lang_svelte-2026.9.0.dev1/src/rbtr_lang_svelte/tests/samples/svelte/greeter.ts

@@ -0,0 +1,5 @@
+// Imported by Greeting.svelte's <script> block.
+
+export function greet(name: string): string {
+  return `Hello, ${name}`;
+}

rbtr_lang_svelte-2026.9.0.dev1/src/rbtr_lang_svelte/tests/test_extraction.py

@@ -0,0 +1,62 @@
+"""SFC chunker edge cases: the markup template as a host chunk."""
+
+from __future__ import annotations
+
+from rbtr.domain.models import ChunkKind
+from rbtr.git import FileEntry
+from rbtr.languages.extract import extract_file
+
+
+def test_svelte_template_extracted_as_host_chunk() -> None:
+    """The SFC markup template is a searchable host (`svelte`) chunk.
+
+    Distinct from the delegated `<script>`/`<style>` chunks: the template is
+    the component's own markup, so it carries the host language.
+    """
+    src = """\
+<script lang="ts">
+  export let name: string = "world";
+</script>
+
+<h1 class="greeting">Hello {name}</h1>
+"""
+    chunks = extract_file(FileEntry("input", "sha1", src.encode()), "svelte")
+    host = [c for c in chunks if c.language == "svelte"]
+    assert host, "expected a svelte-language chunk for the template markup"
+    assert "greeting" in host[0].content
+
+
+def test_svelte_without_template_still_emits_host_chunk() -> None:
+    """A script-only SFC still emits one (empty) host chunk.
+
+    The host chunk records the host language/version for dedup, so a
+    svelte-plugin bump invalidates the file even with no template markup.
+    """
+    src = '<script lang="ts">\n  export const x = 1;\n</script>\n'
+    chunks = extract_file(FileEntry("input", "sha1", src.encode()), "svelte")
+    host = [c for c in chunks if c.language == "svelte"]
+    assert len(host) == 1
+    assert host[0].content == ""
+
+
+def test_sfc_top_level_comment_is_its_own_chunk() -> None:
+    """A comment above the component's markup is searchable content.
+
+    The template chunk excludes it, so it needs a chunk of its own or the
+    banner explaining what a component is for cannot be found.
+    """
+    src = """\
+<!--
+  Greeting: shouts a name.
+-->
+
+<script>
+  let name = "world";
+</script>
+
+<h1>{name}</h1>
+"""
+    chunks = extract_file(FileEntry("input", "sha1", src.encode()), "svelte")
+    comments = [c for c in chunks if c.kind == ChunkKind.COMMENT]
+    assert [(c.line_start, c.line_end) for c in comments] == [(1, 3)]
+    assert "shouts a name" in comments[0].content

rbtr_lang_svelte-2026.9.0.dev1/src/rbtr_lang_svelte/tests/test_samples.py

@@ -0,0 +1,86 @@
+"""Svelte sample extraction: the `samples/svelte/` project through the real pipeline."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+import pytest
+from tree_sitter import Parser
+
+from rbtr.domain.models import Chunk, ChunkKind, Edge
+from rbtr.git import FileEntry
+from rbtr.languages.edges import build_resolution_map, infer_import_edges
+from rbtr.languages.extract import extract_file
+from rbtr.languages.manager import get_manager
+from rbtr.testing import assert_document_fully_chunked, render_edges
+
+if TYPE_CHECKING:
+    from syrupy.assertion import SnapshotAssertion
+
+
+@pytest.fixture
+def project() -> list[tuple[str, str]]:
+    root = Path(__file__).parent / "samples" / "svelte"
+    return [
+        (str(p.relative_to(root)), p.read_text()) for p in sorted(root.rglob("*")) if p.is_file()
+    ]
+
+
+@pytest.fixture
+def chunks(project: list[tuple[str, str]]) -> list[Chunk]:
+    manager = get_manager()
+    out: list[Chunk] = []
+    for path, text in project:
+        lang = manager.detect_language(path) or "svelte"
+        out.extend(extract_file(FileEntry(path, "sha1", text.encode()), lang))
+    return out
+
+
+@pytest.fixture
+def edges(project: list[tuple[str, str]], chunks: list[Chunk]) -> list[Edge]:
+    manager = get_manager()
+    repo_files = {path for path, _ in project}
+    return infer_import_edges(chunks, repo_files, build_resolution_map(manager))
+
+
+def test_emits_expected_kinds(chunks: list[Chunk]) -> None:
+    """The `<script lang="ts">` and `<style lang="scss">` blocks are delegated; the template is a host chunk."""
+    kinds = {c.kind for c in chunks}
+    assert {
+        ChunkKind.FUNCTION,
+        ChunkKind.VARIABLE,
+        ChunkKind.DOC_SECTION,
+        ChunkKind.IMPORT,
+    } <= kinds
+
+
+def test_parses_cleanly(project: list[tuple[str, str]]) -> None:
+    manager = get_manager()
+    for path, text in project:
+        grammar = manager.grammar(manager.detect_language(path) or "svelte")
+        assert grammar is not None
+        assert not Parser(grammar).parse(text.encode()).root_node.has_error, path
+
+
+def test_extraction_matches_snapshot(chunks: list[Chunk], snapshot_json: SnapshotAssertion) -> None:
+    assert chunks == snapshot_json
+
+
+def test_edges_match_snapshot(
+    chunks: list[Chunk], edges: list[Edge], snapshot_json: SnapshotAssertion
+) -> None:
+    assert render_edges(edges, chunks) == snapshot_json
+
+
+def test_every_block_of_every_document_is_chunked(
+    project: list[tuple[str, str]], chunks: list[Chunk]
+) -> None:
+    """A chunker owns the whole document, so no top-level block is dropped."""
+    manager = get_manager()
+    for path, text in project:
+        if manager.detect_language(path) != "svelte":
+            continue
+        grammar = manager.grammar("svelte")
+        assert grammar is not None
+        assert_document_fully_chunked(path, text, chunks, grammar)