feat: experimental svelte compiler

Cargo.toml

@@ -9,6 +9,7 @@ members = [
     "crates/tsv_ts",
     "crates/tsv_css",
     "crates/tsv_svelte",
+    "crates/tsv_svelte_compile",
     "crates/tsv_cli",
     "crates/tsv_debug",
     "crates/tsv_wasm",
@@ -44,6 +45,9 @@ tsv_discover = { path = "crates/tsv_discover" }
 tsv_ts = { path = "crates/tsv_ts", default-features = false }
 tsv_css = { path = "crates/tsv_css", default-features = false }
 tsv_svelte = { path = "crates/tsv_svelte", default-features = false }
+# Svelte→JS compiler + JS canonicalizer. Dev-tooling consumer only (tsv_debug);
+# no shipped artifact links it yet.
+tsv_svelte_compile = { path = "crates/tsv_svelte_compile" }
 
 # External dependencies
 argh = "0.1"
@@ -174,6 +178,7 @@ serde_json.workspace = true
 [dev-dependencies]
 tsv_debug = { path = "crates/tsv_debug" }
 tsv_cli = { path = "crates/tsv_cli" }
+tsv_svelte_compile.workspace = true
 tokio = { workspace = true, features = ["rt-multi-thread", "macros"] }
 futures-util.workspace = true
 bumpalo.workspace = true

README.md

@@ -66,12 +66,12 @@ Future features (unknown order):
   but the lift to support it is small)
 - JS parsing diagnostics (test262 negative cases)
 - CSS error recovery (recover past invalid CSS per the spec)
+- Svelte compiler (partially implemented, not ready for usage)
 - later:
   - TypeScript 7 integration (the Go impl), unlocking:
     - svelte-check replacement
     - LSP
     - linter - type aware, initially focused on serializable data-only plugins for extensibility
-  - Svelte compiler (exact mirror, maybe out of scope, see [rsvelte](https://github.com/baseballyama/rsvelte))
   - bundling is probably out of scope 
   - [discussion](https://github.com/fuzdev/tsv/discussions) welcome
 

crates/tsv_css/src/ast/internal.rs

@@ -765,6 +765,27 @@ pub struct CssAtrule<'arena> {
     pub span: Span,
 }
 
+impl CssAtrule<'_> {
+    /// The at-rule's **public-AST prelude** — the exact string Svelte's parser exposes as
+    /// `node.prelude` (its `read_value(...).trim()`, block comments elided). Routes through
+    /// the wire-JSON prelude reconstruction ([`convert_prelude_to_string`]), the single
+    /// fixture-gated definition of that shape, so a consumer that must agree with the
+    /// oracle's `node.prelude` byte-for-byte — the Svelte compiler's `@keyframes` name
+    /// collection and its `-global-` prefix test — reads the identical bytes rather than the
+    /// printer-facing [`PreludeValue::Raw`] `content`, which is CSS-whitespace-trimmed and
+    /// comment-preserving and so diverges on a prelude carrying a comment or JS-only
+    /// whitespace (`@keyframes spin /* c */`, a trailing vertical tab / NBSP).
+    ///
+    /// A pure visibility bridge over the writer's own reconstruction — no parse, printer, or
+    /// wire behavior of its own.
+    ///
+    /// [`convert_prelude_to_string`]: crate::ast::convert::convert_prelude_to_string
+    #[cfg(feature = "convert")]
+    pub fn public_prelude<'src>(&self, source: &'src str) -> std::borrow::Cow<'src, str> {
+        crate::ast::convert::convert_prelude_to_string(&self.prelude, source)
+    }
+}
+
 /// At-rule block - can contain rules, declarations, or nested at-rules
 #[derive(Debug, Clone)]
 pub struct CssAtruleBlock<'arena> {

crates/tsv_debug/CLAUDE.md

@@ -2,7 +2,7 @@
 
 > Developer tooling crate — fixtures, comparisons, corpus runs. Embeds a Deno sidecar for canonical JS tools.
 
-Unlike `tsv_cli` (pure Rust, production binary), `tsv_debug` exists to validate and debug `tsv` against external sources of truth: Prettier (formatting), Svelte's compiler (parsing), acorn-typescript (TS AST shape). The binary `tsv_debug` powers `deno task fixtures:*`, `deno task corpus:compare:format`, `deno task bench`, and friends. For the command catalog see [../../CLAUDE.md §Debug Tooling](../../CLAUDE.md#debug-tooling); the audit gates are cataloged in [../../docs/audits.md](../../docs/audits.md), the profiling tools in [../../docs/performance.md](../../docs/performance.md).
+Unlike `tsv_cli` (pure Rust, production binary), `tsv_debug` exists to validate and debug `tsv` against external sources of truth: Prettier (formatting), Svelte's compiler (parsing), acorn-typescript (TS AST shape). The binary `tsv_debug` powers `deno task fixtures:*`, `deno task corpus:compare:format`, `deno task bench`, and friends. For the command catalog see [../../CLAUDE.md §Debug Tooling](../../CLAUDE.md#debug-tooling); the audit gates are cataloged in [../../docs/audits.md](../../docs/audits.md), the profiling tools in [../../docs/performance.md](../../docs/performance.md), the Svelte-compiler harnesses in [../../docs/compile_tooling.md](../../docs/compile_tooling.md).
 
 ## Architecture Position
 
@@ -15,6 +15,7 @@ The Deno sidecar is a **long-running subprocess pool** spawned lazily on first u
 - `deno/` — Sidecar plumbing: `actor.rs` owns one spawned process (`mod.rs` holds the pool + round-robin dispatch), `protocol.rs` is the JSON-lines wire format, `sidecar.ts` is the embedded TypeScript that runs inside Deno and dispatches to prettier / svelte (parse **and** `compile`) / acorn / parseCss. Pinned npm versions live in `sidecar.ts`. The `svelte-render-key` tool compiles for the server target and reduces the baked template to its browser-visible render (block-aware whitespace collapse, `<script>`/`<style>`/comments stripped) — the authoritative oracle behind the fixture render-equivalence check.
 - `fixtures/` — The fixture workflow surface — `model.rs` holds the data model (`InputType`, `Fixture`, divergence-suffix rules), `discovery.rs` walks the fixtures tree, `variants.rs` discovers variant files, `mod.rs` keeps IO/parse helpers, `validation/` is the validator (`fixtures_validate`: structure rules, per-phase checks, errors, summary — including `phases/render_equivalence.rs`, which asserts every Svelte whitespace variant *renders* like `input`, not merely that it normalizes to it), `audit_signature.rs` pins prettier's multi-pass chain.
 - `test262/` — ECMAScript conformance runner: `discovery.rs` walks the test262 tree, `frontmatter.rs` parses the YAML harness metadata, `runner.rs` drives our parser (`run_test`) and grades the strict subset into the differential `Manifest` (`grade_for_manifest`, sharing the `classify` skip logic with `run_test`). Pure Rust — no Deno needed. The `test262 --emit-manifest` JSON feeds `benches/js/diagnostics/test262_compare.ts` for the tsv-vs-oxc-parser comparison.
+- `cli/commands/compile_fuzz/` — the differential compile fuzzer: `anchors.rs` reads the splice offsets off tsv's Svelte parse (fragment gaps, wrappable subtrees, attribute slots, script slots, and the server-DROPPED regions — a `{:catch}` body, a `<svelte:boundary>` `pending`/`failed` snippet), `operators.rs` holds the eleven feature-level mutation operators (the cross-component donor graft, and the exotic-whitespace probe over the JS/CSS/attribute/template positions whose whitespace classes disagree), and `mod.rs` owns the generate-then-grade loop. Operators are AST/feature level rather than byte level because a compile mutant must stay oracle-**compilable** to grade anything; grading runs tsv's `compile()` first and skips the sidecar on a refusal. See [../../docs/compile_tooling.md](../../docs/compile_tooling.md).
 - `diff.rs` — Colored text / JSON diffing with line-width annotations (used by `compare`, `ast_diff`, validation failures).
 - `error.rs` — `DebugError` — wraps `DenoError`, `io::Error`, `serde_json::Error`; exposes `hint()` for actionable messages.
 - `cli/` — argh `TopLevel`/`Subcommand` dispatch in `mod.rs` + per-command `FromArgs` modules under `cli/commands/`. Shared three-mode input plumbing (file path / `--content` / `--stdin`) comes from `tsv_cli::cli::input::InputArgs`.

crates/tsv_debug/Cargo.toml

@@ -49,6 +49,7 @@ tsv_lang = { workspace = true }
 tsv_svelte = { workspace = true, features = ["convert"] }
 tsv_ts = { workspace = true, features = ["convert", "debug_lex"] }
 tsv_css = { workspace = true, features = ["convert", "debug_lex"] }
+tsv_svelte_compile = { workspace = true }
 tsv_html = { workspace = true }
 argh.workspace = true
 serde.workspace = true

crates/tsv_debug/src/audit/mod.rs

@@ -26,6 +26,11 @@
 // verify layer is internally feature-gated.)
 pub(crate) mod properties;
 
+// The ratchet is NOT gated: `compile_corpus_compare --ratchet` (the validation-suite
+// gate) drives no comment ledger, so it must exist in a default build. It is pure
+// generic snapshot plumbing with no ledger dependency of its own.
+pub(crate) mod ratchet;
+
 // The injection machinery is only reachable through `gap_audit` / `blank_audit`,
 // both themselves behind the `comment_check` feature (they arm
 // `tsv_lang::comment_ledger`), so gate these too — otherwise they read as dead
@@ -35,8 +40,6 @@ pub(crate) mod node_edge;
 #[cfg(feature = "comment_check")]
 pub(crate) mod parallel;
 #[cfg(feature = "comment_check")]
-pub(crate) mod ratchet;
-#[cfg(feature = "comment_check")]
 pub(crate) mod report;
 #[cfg(feature = "comment_check")]
 pub(crate) mod sites;

crates/tsv_debug/src/cli/commands/canonical_compile.rs

@@ -0,0 +1,107 @@
+use crate::cli::CliError;
+use crate::deno::{self, SvelteCompileOutput, SvelteGenerate};
+use argh::FromArgs;
+use tsv_cli::cli::input::{InputArgs, ParserType};
+use tsv_cli::json_utils::to_json_with_tabs;
+
+/// Compile Svelte with the canonical Svelte compiler (the deterministic oracle).
+#[derive(FromArgs, Debug)]
+#[argh(subcommand, name = "canonical_compile")]
+#[allow(clippy::struct_excessive_bools)] // independent CLI flags
+pub struct CanonicalCompileCommand {
+    /// compile target: server | client (default: server)
+    #[argh(option, default = "SvelteGenerate::Server")]
+    target: SvelteGenerate,
+
+    /// also print the compiled CSS
+    #[argh(switch)]
+    css: bool,
+
+    /// development-mode output
+    #[argh(switch)]
+    dev: bool,
+
+    /// emit { js, css, warnings } as JSON
+    #[argh(switch)]
+    json: bool,
+
+    /// content to compile
+    #[argh(option)]
+    content: Option<String>,
+
+    /// read from stdin
+    #[argh(switch)]
+    stdin: bool,
+
+    /// file path
+    #[argh(positional)]
+    file: Option<String>,
+}
+
+impl CanonicalCompileCommand {
+    pub(crate) fn run(self) -> Result<(), CliError> {
+        // Compile is Svelte-only, so force the parser: --content/--stdin don't
+        // require an explicit --parser, and a file argument's extension is ignored.
+        let input_args = InputArgs {
+            content: self.content,
+            stdin: self.stdin,
+            parser: Some(ParserType::Svelte),
+            file: self.file,
+        };
+        let input = match input_args.resolve() {
+            Ok((input, _parser)) => input,
+            Err(e) => {
+                eprintln!("Error: {e}");
+                return Err(CliError::Failed);
+            }
+        };
+
+        let rt = super::create_runtime();
+        match rt.block_on(deno::svelte_compile(input.content(), self.target, self.dev)) {
+            Ok(output) => print_output(&output, self.css, self.json),
+            Err(err) => {
+                eprintln!("Error compiling: {err}");
+                Err(CliError::Failed)
+            }
+        }
+    }
+}
+
+/// Print the compile output: JSON when `as_json`, else the JS (and the CSS when
+/// `show_css`, under a delimiting comment).
+fn print_output(
+    output: &SvelteCompileOutput,
+    show_css: bool,
+    as_json: bool,
+) -> Result<(), CliError> {
+    if as_json {
+        match to_json_with_tabs(output) {
+            Ok(json) => {
+                println!("{json}");
+                Ok(())
+            }
+            Err(err) => {
+                eprintln!("Error serializing output: {err}");
+                Err(CliError::Failed)
+            }
+        }
+    } else {
+        print_block(&output.js);
+        if show_css {
+            println!("/* --- css --- */");
+            match &output.css {
+                Some(css) => print_block(css),
+                None => println!("/* (none) */"),
+            }
+        }
+        Ok(())
+    }
+}
+
+/// Print `text`, ensuring it ends with exactly one trailing newline.
+fn print_block(text: &str) {
+    print!("{text}");
+    if !text.ends_with('\n') {
+        println!();
+    }
+}