@rsvelte/compiler 0.2.0 → 0.3.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Yuichiro Yamashita
+
+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.

package/README.md

@@ -1,182 +1,322 @@
 # rsvelte
 
-A high-performance Rust implementation of the Svelte compiler. Drop-in replacement for `svelte/compiler` with up to 100x performance improvement.
+> **⚠️ Early Stage Project** — rsvelte already passes the official Svelte 5 compiler test suite end-to-end, but it's still pre-1.0. APIs, output, and behaviour may change without notice. Use it in production at your own risk.
 
-## Installation
+**A Rust port of the official Svelte 5 compiler, built to slot natively into the [OXC](https://oxc.rs/) ecosystem.**
+
+## Why rsvelte exists
+
+The end goal isn't "another Svelte compiler" — it's making Svelte a first-class citizen of OXC's Rust-native JavaScript/TypeScript toolchain.
+
+Today, the native JS toolchain that has grown up around OXC — `oxlint`, `oxfmt`, [Rolldown](https://rolldown.rs/), and [`tsgo`](https://github.com/microsoft/typescript-go) (wired into `oxlint` via [`tsgolint`](https://github.com/oxc-project/tsgolint)) — can only see `.js` / `.ts` / `.jsx` / `.tsx` files. `.svelte` files are invisible to them because parsing Svelte requires running the JavaScript-based Svelte compiler, which native tools can't and won't link against. The result: Svelte developers don't get the order-of-magnitude speed-ups that the rest of the JS ecosystem is starting to take for granted.
+
+rsvelte fixes that at the source. By porting the compiler — **and** the surrounding ecosystem hot paths (`svelte2tsx`, `svelte-check`, `vite-plugin-svelte`) — to Rust on top of OXC's own parser, codegen, and semantic stack, rsvelte gives OXC a Svelte surface it can call into directly. Once upstreamed, that surface unlocks:
+
+- **`oxlint`** — lint `<script>` blocks and Svelte-specific patterns at OXC speed (a Rust path forward for `eslint-plugin-svelte`).
+- **`oxfmt`** — format `.svelte` files alongside the rest of the project (a Rust path forward for `prettier-plugin-svelte`).
+- **Rolldown** — native bundling of Svelte projects through OXC's parser stack, without a JS-side compiler hop.
+- **`tsgo` + `tsgolint`** — type-checking and type-aware linting over `.svelte` files. Already wired into `@rsvelte/svelte-check` today as the correctness bridge.
+
+Until we get there, the drop-in replacement story — `@rsvelte/compiler`, `@rsvelte/svelte-check`, `@rsvelte/vite-plugin-svelte` — lets you use rsvelte today and acts as the correctness bridge that proves the Rust port is byte-identical to upstream Svelte.
+
+## Packages
+
+All packages ship under the `@rsvelte` scope on npm.
+
+| Package | Drop-in for | Status |
+|---|---|---|
+| [`@rsvelte/compiler`](npm/compiler) | [`svelte/compiler`](https://svelte.dev/docs/svelte-compiler) (wasm) | ✅ 100% test compat ([details](#compatibility)) |
+| [`@rsvelte/svelte2tsx`](npm/svelte2tsx) | [`svelte2tsx`](https://github.com/sveltejs/language-tools/tree/master/packages/svelte2tsx) | ✅ 245 / 245 fixtures |
+| [`@rsvelte/svelte-check`](npm/svelte-check) | [`svelte-check`](https://github.com/sveltejs/language-tools/tree/master/packages/svelte-check) CLI | ✅ v1.0 — walker + overlay + tsgo backend + incremental + watch |
+| [`@rsvelte/vite-plugin-svelte`](https://github.com/baseballyama/vite-plugin-svelte/tree/rsvelte) | [`@sveltejs/vite-plugin-svelte`](https://github.com/sveltejs/vite-plugin-svelte) | ✅ v1.0 — fork that routes through the NAPI compiler |
+| [`@rsvelte/vite-plugin-svelte-native`](npm/vite-plugin-svelte-native) | — | NAPI bindings the Vite plugin and other Node tools consume |
+
+See [`docs/ecosystem-implementation-plan.md`](docs/ecosystem-implementation-plan.md) for the full ecosystem port plan, including which upstream tools are intentionally **out of scope** (and where they're being routed instead — usually back to OXC).
+
+## Quick start
+
+### Use as `svelte/compiler` (wasm)
 
 ```bash
 npm install @rsvelte/compiler
 ```
 
-## Usage
-
-### Basic Usage
-
 ```js
-import { compile, parse, VERSION } from '@rsvelte/compiler';
+import { compile, compileModule, parse, VERSION } from '@rsvelte/compiler';
 
-const result = compile('<h1>Hello {name}!</h1>', {
+const result = compile('<h1>Hello, {name}!</h1>', {
+  generate: 'client',     // or 'server'
   filename: 'App.svelte',
-  generate: 'client',
 });
 
 console.log(result.js.code);
+console.log(result.css?.code);
+
+// Compile a Svelte module (.svelte.js / .svelte.ts)
+const moduleResult = compileModule('export const count = $state(0);', {
+  filename: 'counter.svelte.js',
+});
+
+// Parse to AST
+const ast = parse('<h1>Hello</h1>', { modern: true });
+
+console.log(VERSION); // upstream Svelte version this build targets
 ```
 
-### With Vite + vite-plugin-svelte
+The public surface mirrors [`svelte/compiler`](https://svelte.dev/docs/svelte-compiler) — `compile`, `compileModule`, `parse`, and `VERSION` are all available. Output is byte-identical to the official compiler on every in-scope fixture (see [Compatibility](#compatibility)).
+
+> **Heads-up:** a few function-valued options can't cross the wasm / NAPI boundary. See [Compiler option compatibility](#compiler-option-compatibility) before passing `cssHash` or `warningFilter`.
+
+### Use with Vite
 
-Use `resolve.alias` to replace the Svelte compiler:
+[`@rsvelte/vite-plugin-svelte`](https://github.com/baseballyama/vite-plugin-svelte/tree/rsvelte) is a fork of `@sveltejs/vite-plugin-svelte` that swaps in the rsvelte compiler. The public API matches upstream exactly — your `vite.config.js` doesn't need to change.
+
+```bash
+npm install -D @rsvelte/vite-plugin-svelte
+```
 
 ```js
 // vite.config.js
+import { svelte } from '@rsvelte/vite-plugin-svelte';
 import { defineConfig } from 'vite';
-import { svelte } from '@sveltejs/vite-plugin-svelte';
 
 export default defineConfig({
-  resolve: {
-    alias: {
-      'svelte/compiler': '@rsvelte/compiler',
-    },
-  },
   plugins: [svelte()],
 });
 ```
 
-## API
+### Use with SvelteKit
 
-### `compile(source, options?)`
+SvelteKit pulls in `@sveltejs/vite-plugin-svelte` internally, so the cleanest swap is a package-manager override that redirects the upstream plugin to the rsvelte fork. With pnpm:
 
-Compile a Svelte component to JavaScript.
-
-```js
-const result = compile(source, {
-  dev: false,
-  generate: 'client', // 'client' | 'server'
-  filename: 'Component.svelte',
-  css: 'external', // 'injected' | 'external'
-  // ... see CompileOptions for all options
-});
+```bash
+pnpm add -D @rsvelte/vite-plugin-svelte
+```
 
-// result.js.code - Generated JavaScript
-// result.js.map - Source map
-// result.css?.code - Generated CSS (if css: 'external')
-// result.css?.map - CSS source map
-// result.warnings - Compiler warnings
-// result.metadata.runes - Whether component uses runes
+```jsonc
+// package.json
+{
+  "pnpm": {
+    "overrides": {
+      "@sveltejs/vite-plugin-svelte": "npm:@rsvelte/vite-plugin-svelte@^0.1.0"
+    }
+  }
+}
 ```
 
-### `compileModule(source, options?)`
+Then `pnpm install`. No changes to `vite.config.js` or `svelte.config.js` are needed. (npm and yarn ship equivalent `overrides` / `resolutions` fields if you prefer those.)
 
-Compile a Svelte module (`.svelte.js` / `.svelte.ts`).
+### Type-check with `svelte-check`
 
-```js
-const result = compileModule(source, {
-  dev: false,
-  generate: 'client',
-  filename: 'utils.svelte.js',
-});
+`@rsvelte/svelte-check` is a drop-in CLI replacement for `svelte-check`, backed by a Rust walker plus a tsgo overlay for `<script lang="ts">` diagnostics.
+
+```bash
+npm install -D @rsvelte/svelte-check
+npx svelte-check
 ```
 
-### `parse(source, options?)`
+Common flags:
+
+```bash
+npx svelte-check --workspace .              # type-check the current workspace
+npx svelte-check --tsgo                     # run tsgo against the .svelte overlay (recommended)
+npx svelte-check --watch                    # re-check on file changes
+npx svelte-check --incremental              # reuse cached overlay between runs
+npx svelte-check --output machine           # JSON-friendly output for CI
+npx svelte-check --fail-on-warnings         # treat warnings as errors
+npx svelte-check --compiler-warnings "css-unused-selector:ignore"
+```
 
-Parse a Svelte component into an AST.
+See `npx svelte-check --help` for the full list. The CLI flag set is a superset of upstream's — every upstream flag works, plus a few rsvelte-specific ones (`--tsgo`, `--emit-overlay`).
+
+### Convert `.svelte` to `.tsx` (`svelte2tsx`)
+
+```bash
+npm install @rsvelte/svelte2tsx
+```
 
 ```js
-const ast = parse('<h1>Hello</h1>', {
-  modern: true, // Use modern AST format
+import { svelte2tsx } from '@rsvelte/svelte2tsx';
+
+const result = await svelte2tsx('<h1>Hello, {name}!</h1>', {
+  filename: 'App.svelte',
+  isTsFile: true,
+  mode: 'ts',          // or 'dts' to emit a declaration file
+  version: '5',
 });
+
+console.log(result.code);          // the synthesised .tsx
+console.log(result.exportedNames); // { props, all }
 ```
 
-### `preprocess(source, preprocessors, options?)`
+Useful if you're building your own language tooling on top of the same surface `svelte-check`, the Svelte language server, and `tsc` all rely on.
 
-Preprocess a Svelte component (async).
+### Embed in a Rust crate
 
-```js
-const processed = await preprocess(source, [
-  {
-    markup({ content, filename }) {
-      return { code: transformedContent };
-    },
-    script({ content, filename }) {
-      return { code: transformedContent };
-    },
-    style({ content, filename }) {
-      return { code: transformedContent };
-    },
-  },
-], { filename: 'App.svelte' });
+```toml
+[dependencies]
+svelte-compiler-rust = { git = "https://github.com/baseballyama/rsvelte" }
+```
+
+```rust
+use svelte_compiler_rust::{compile, CompileOptions};
+
+let source = r#"<h1>Hello, {name}!</h1>"#;
+let result = compile(source, CompileOptions::default()).unwrap();
+println!("{}", result.js.code);
 ```
 
-### `print(ast, options?)`
+The Rust API is the same surface OXC will eventually wire `oxlint` / `oxfmt` into. Unlike the JS surface, the Rust `CompileOptions` honours **every** field — including `css_hash` and `warning_filter` as real Rust closures.
 
-Print an AST back to source code.
+## Compiler option compatibility
 
-```js
-const ast = parse(source, { modern: true });
-const { code } = print(ast);
+The JS-facing surfaces (`@rsvelte/compiler` wasm bundle, `@rsvelte/vite-plugin-svelte-native` NAPI bindings) accept the full `svelte/compiler#CompileOptions` shape, but **function-valued** options can't currently cross the language boundary. The Rust core has no way to call back into JavaScript, so callback-shaped fields are accepted (so the TypeScript types stay drop-in compatible with upstream Svelte) and then **silently ignored**.
+
+If your build relies on any of these, the value won't take effect. Use the workarounds below.
+
+| Option | Behaviour in rsvelte (JS surface) | Workaround |
+|---|---|---|
+| `cssHash({ hash, name, filename, css }) => string` | Ignored. CSS scope classes fall back to the default `svelte-<base36hash>` scheme — identical to upstream Svelte's default `cssHash`. | Pre-compute the hash on the JS side and pass it as `cssHashOverride: '<hash>'` — an rsvelte-specific extension that injects a deterministic string. |
+| `warningFilter(warning) => boolean` | Ignored. All compiler warnings are returned unfiltered. | Filter `result.warnings` yourself after compilation. |
+
+Everything else (`generate`, `css`, `dev`, `hmr`, `sourcemap`, `runes`, `compatibility`, `experimental.async`, `preserveComments`, `preserveWhitespace`, `customElement`, `accessors`, `namespace`, `immutable`, `modernAst`, `discloseVersion`, `outputFilename`, `cssOutputFilename`, …) matches upstream exactly. The full list of accepted fields is mirrored in [`npm/vite-plugin-svelte-native/index.d.ts`](npm/vite-plugin-svelte-native/index.d.ts).
+
+The Rust API (`svelte_compiler_rust::compile`) has no such restriction — `css_hash: Option<CssHashFn>` and `warning_filter: Option<WarningFilterFn>` work as real `Arc<dyn Fn>` closures.
+
+## Performance
+
+Per-task benchmark across 3,637 real `.svelte` files, 10 iterations (3 warmup), against the official `svelte/compiler`:
+
+| Task | JS (`svelte/compiler`) | Rust (single-threaded) | Rust (multi-threaded) | Multi vs JS |
+|---|---:|---:|---:|---:|
+| **Full pipeline** — parse / analyze / codegen | 864.8 ms | 381.1 ms | 50.1 ms | **17.3×** |
+| **Parser only** — phase 1, isolated | 187.5 ms | 8.7 ms | 1.9 ms | **99.5×** |
+| **`svelte2tsx`** — `.svelte` → `.tsx` generation | 306.1 ms | 115.3 ms | 16.0 ms | **19.1×** |
+| **`svelte-check`** — CLI, 500-file workspace | 2,088.0 ms | 46.9 ms | 13.8 ms | **151.5×** |
+
+> Apple M1 Pro · 10-core arm64 · 3,637 `.svelte` files · 10 iterations (3 warmup). Recorded 2026-05-24 at commit `da6b3c8`. Live numbers, charts, and reproduction steps live on the [benchmark page](https://baseballyama.github.io/rsvelte/benchmark) (or run `node scripts/run-benchmark.mjs > docs/static/benchmark-results.json` locally).
+
+A single-threaded **100× speedup** over the JS compiler is one of this project's explicit goals — the parser is already at multi-threaded `99.5×` and `svelte-check` at `151.5×`, but the full pipeline is still climbing. Current numbers are a snapshot, not a ceiling.
+
+## Compatibility
+
+<!-- svelte-target-version -->
+**Targeting Svelte `v5.51.5`** ([`8ea33bf7fe86`](https://github.com/sveltejs/svelte/commit/8ea33bf7fe86)) — automatically maintained by `pnpm run update-docs`.
+<!-- /svelte-target-version -->
+
+Current compatibility with the official Svelte compiler test suite:
+
+| Test Suite | Pass | Total | Status | Notes |
+|---|---:|---:|---|---|
+| Parser Modern | 22 | 22 | 100% | |
+| Parser Legacy | 82 | 83 | 100% | 1 skipped (acorn vs OXC comment attachment) |
+| Compiler Snapshot | 28 | 28 | 100% | |
+| CSS | 179 | 179 | 100% | |
+| Validator | 324 | 325 | 100% | 1 skipped (`error-mode-warn`) |
+| Compiler Errors | 144 | 144 | 100% | |
+| Runtime Runes | 865 | 865 | 100% | |
+| Runtime Legacy | 1,202 | 1,202 | 100% | |
+| Runtime Browser | 31 | 31 | 100% | |
+| Hydration | 78 | 78 | 100% | |
+| SSR | 82 | 82 | 100% | |
+| Preprocess | 19 | 19 | 100% | |
+| Print | 40 | 40 | 100% | |
+| svelte2tsx | 245 | 245 | 100% | 2 skipped (`expected.error.json` error fixtures) |
+| **Total (in-scope)** | **3,341** | **3,341** | **100%** | |
+| Migrate | 0 | 76 | — | **Out of scope** — rsvelte is a Svelte 5 compiler port, not a 4→5 migrator |
+| Sourcemaps | 0 | 0 | — | No fixtures yet |
+
+Re-run `pnpm run test-and-update` to refresh these numbers.
+
+## Goals
+
+1. **OXC ecosystem integration** — be the Svelte surface that `oxlint`, `oxfmt`, Rolldown, and `tsgo` (via `tsgolint`) all link against. This is the project's reason for existing; everything else is a step toward it.
+2. **100% test compatibility** with the official `svelte/compiler` test suite — keeps the Rust port provably equivalent to upstream while OXC integration lands.
+3. **100× single-threaded speedup** over the JS compiler via Rust + OXC.
+4. **Drop-in replacements** for the ecosystem hot paths (`svelte/compiler`, `svelte-check`, `vite-plugin-svelte`, `svelte2tsx`) so you can adopt rsvelte today without touching the rest of your build.
+5. **Ecosystem port** — see [`docs/ecosystem-implementation-plan.md`](docs/ecosystem-implementation-plan.md) for the multi-wave plan.
+
+## Architecture
+
+The directory structure mirrors `submodules/svelte/packages/svelte/src/compiler/`:
+
+```
+src/compiler/phases/
+├── 1_parse/     # Parsing (Svelte syntax → AST)
+├── 2_analyze/   # Analysis (scope tree, bindings, rune detection)
+└── 3_transform/ # Code generation (AST → JS/CSS, client + SSR)
 ```
 
-### `parseCss(source)`
+Key design decisions:
 
-Parse CSS into an AST.
+- JavaScript parsing, semantic analysis, and codegen all run on OXC — the same crates `oxlint` / `oxfmt` use, so the OXC integration target stays cheap.
+- Memory-efficient AST (u32 positions, `compact_str`, `bumpalo`-arena allocation on hot paths).
+- Direct AST passing between phases — no re-parsing.
+- Parallel processing with `rayon`.
+- No backward-compat shims for internal APIs — refactor freely.
 
-### `VERSION`
+## Development
 
-The compiler version string.
+### Setup
 
-```js
-import { VERSION } from '@rsvelte/compiler';
-console.log(VERSION); // "0.1.0"
+```bash
+git submodule update --init --recursive
+git config core.hooksPath .githooks
+pnpm install
+pnpm run generate-fixtures   # required before running tests
 ```
 
-## Limitations
+### Build & test
 
-### Callback Options Not Supported
+```bash
+cargo build
+cargo test                                          # all tests
+cargo test --release                                # recommended for full runs
+cargo test --test parser_fixtures -- --nocapture    # single suite
+pnpm run compatibility-report                       # generate compatibility JSON
+pnpm run test-and-update                            # refresh report + docs
+./scripts/bench.sh                                  # JS vs Rust benchmark
+```
 
-The following options accept JavaScript callback functions and are **not currently supported** in rsvelte. These options will be silently ignored, and the default behavior will be used instead:
+The pre-commit hook (`.githooks/pre-commit`) runs `cargo fmt` and `cargo clippy` automatically.
 
-| Option | Description | Default Behavior |
-|--------|-------------|-----------------|
-| `cssHash` | Custom function to generate CSS hash for scoping | Uses the built-in hash function (same algorithm as the official Svelte compiler default) |
-| `warningFilter` | Function to filter compiler warnings | All warnings are included in the result |
+### Docker (optional)
 
-**Why?** rsvelte is implemented in Rust and compiled to a native binary. JavaScript callback functions cannot be directly executed inside the Rust runtime. Supporting these would require crossing the Rust-JavaScript boundary for each invocation, which would negate the performance benefits.
+A `Dockerfile` and `docker-compose.yml` provide a reproducible toolchain (Rust nightly + Node 22 + pnpm):
 
-**Workaround for `warningFilter`:** Filter warnings from the result after compilation:
+```bash
+docker compose up -d
+docker compose exec dev bash
+docker compose exec dev cargo test
+```
 
-```js
-const result = compile(source, options);
-const filteredWarnings = result.warnings.filter(
-  (w) => w.code !== 'a11y-missing-attribute'
-);
+VS Code Dev Containers ("Reopen in Container") also works.
+
+### Upgrading Svelte
+
+```bash
+./scripts/upgrade-svelte.sh 5.52.0
 ```
 
-**Workaround for `cssHash`:** Currently no workaround. The default hash function is used. If you require a custom hash, please open an issue.
+Updates the Svelte submodule, rebuilds, regenerates fixtures, and refreshes the compatibility report.
+
+## Known incompatibilities
 
-### Not Yet Implemented
+### Parser Legacy: `javascript-comments` (1 test skipped)
 
-| API | Status |
-|-----|--------|
-| `migrate()` | Not implemented - throws error |
-| `walk()` | Deprecated in Svelte 5 - throws error directing to estree-walker |
+The official compiler uses acorn and attaches comments to AST nodes as `leadingComments` / `trailingComments`. rsvelte uses OXC, where comments are provided as a separate list. This only affects the legacy AST format (Svelte 4 compatibility mode) and does **not** impact compiled output or runtime behavior.
 
-## Platform Support
+### Validator: `error-mode-warn` (1 test skipped)
 
-rsvelte ships native binaries for the following platforms:
+Tests an error-mode option not yet wired through rsvelte's diagnostic pipeline. Compiled output is unaffected.
 
-| Platform | Architecture | Package |
-|----------|-------------|---------|
-| macOS | ARM64 (Apple Silicon) | `@rsvelte/binding-darwin-arm64` |
-| macOS | x64 (Intel) | `@rsvelte/binding-darwin-x64` |
-| Linux | x64 | `@rsvelte/binding-linux-x64-gnu` |
-| Linux | ARM64 | `@rsvelte/binding-linux-arm64-gnu` |
-| Windows | x64 | `@rsvelte/binding-win32-x64-msvc` |
+### svelte2tsx: 2 error-fixture skips
 
-Native binaries are installed automatically via `optionalDependencies`. If no native binary is available for your platform, an error will be thrown at runtime.
+Two svelte2tsx fixtures shaped around `expected.error.json` (error-path assertions) are skipped pending a structured error-fixture runner.
 
-## Svelte Compatibility
+### Function-valued compiler options (JS surface)
 
-rsvelte targets compatibility with **Svelte 5** (`svelte/compiler`). It passes 100% of the official Svelte compiler test suite (3028/3028 tests).
+See [Compiler option compatibility](#compiler-option-compatibility). The Rust API is unaffected.
 
 ## License
 

package/package.json

@@ -1,45 +1,31 @@
 {
   "name": "@rsvelte/compiler",
-  "version": "0.2.0",
-  "description": "A high-performance Rust implementation of the Svelte compiler - drop-in replacement",
-  "author": "baseballyama",
   "type": "module",
-  "main": "index.cjs",
-  "module": "index.js",
-  "types": "index.d.ts",
-  "exports": {
-    ".": {
-      "types": "./index.d.ts",
-      "import": "./index.js",
-      "require": "./index.cjs"
-    }
+  "description": "A high-performance Rust implementation of the Svelte compiler",
+  "version": "0.3.1",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/baseballyama/rsvelte.git"
   },
   "files": [
-    "index.js",
-    "index.cjs",
-    "index.d.ts",
-    "README.md"
+    "svelte_compiler_rust_bg.wasm",
+    "svelte_compiler_rust.js",
+    "svelte_compiler_rust.d.ts"
+  ],
+  "main": "svelte_compiler_rust.js",
+  "homepage": "https://github.com/baseballyama/rsvelte#readme",
+  "types": "svelte_compiler_rust.d.ts",
+  "sideEffects": [
+    "./snippets/*"
   ],
-  "optionalDependencies": {
-    "@rsvelte/binding-darwin-arm64": "0.2.0",
-    "@rsvelte/binding-darwin-x64": "0.1.0",
-    "@rsvelte/binding-linux-x64-gnu": "0.1.0",
-    "@rsvelte/binding-linux-arm64-gnu": "0.1.0",
-    "@rsvelte/binding-win32-x64-msvc": "0.1.0"
-  },
   "keywords": [
     "svelte",
     "compiler",
     "rust",
-    "napi",
-    "performance"
+    "wasm"
   ],
-  "license": "MIT",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/baseballyama/svelte-compiler-rust"
-  },
-  "engines": {
-    "node": ">= 18"
+  "bugs": {
+    "url": "https://github.com/baseballyama/rsvelte/issues"
   }
-}
+}

package/svelte_compiler_rust.d.ts

@@ -0,0 +1,108 @@
+/* tslint:disable */
+/* eslint-disable */
+
+/**
+ * Result of compiling a Svelte component.
+ */
+export class CompileResultWasm {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    readonly css: string;
+    readonly error: string | undefined;
+    readonly js: string;
+    readonly success: boolean;
+}
+
+/**
+ * Result of parsing a Svelte component.
+ */
+export class ParseResultWasm {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    readonly ast: string;
+    readonly error: string | undefined;
+    readonly success: boolean;
+}
+
+/**
+ * Compile a Svelte component to client-side JavaScript.
+ */
+export function compile_client(source: string, name: string): CompileResultWasm;
+
+/**
+ * Compile a Svelte component to server-side JavaScript.
+ */
+export function compile_server(source: string, name: string): CompileResultWasm;
+
+/**
+ * Initialize panic hook for better error messages in the browser console.
+ */
+export function init(): void;
+
+/**
+ * Parse a Svelte component and return the AST as JSON.
+ */
+export function parse_svelte(source: string): ParseResultWasm;
+
+/**
+ * Convert a Svelte component to TypeScript/TSX. Mirrors the napi `svelte2tsx`
+ * shape — `options_json` and the return value are JSON strings so the wasm
+ * boundary stays at primitive types and no bespoke `wasm_bindgen` struct is
+ * needed for every field of `Svelte2TsxResult`.
+ */
+export function svelte2tsx(source: string, options_json: string): string;
+
+/**
+ * Get the version of the compiler.
+ */
+export function version(): string;
+
+export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
+
+export interface InitOutput {
+    readonly memory: WebAssembly.Memory;
+    readonly __wbg_compileresultwasm_free: (a: number, b: number) => void;
+    readonly __wbg_parseresultwasm_free: (a: number, b: number) => void;
+    readonly compile_client: (a: number, b: number, c: number, d: number) => number;
+    readonly compile_server: (a: number, b: number, c: number, d: number) => number;
+    readonly compileresultwasm_css: (a: number) => [number, number];
+    readonly compileresultwasm_error: (a: number) => [number, number];
+    readonly compileresultwasm_js: (a: number) => [number, number];
+    readonly compileresultwasm_success: (a: number) => number;
+    readonly parse_svelte: (a: number, b: number) => number;
+    readonly parseresultwasm_ast: (a: number) => [number, number];
+    readonly parseresultwasm_error: (a: number) => [number, number];
+    readonly parseresultwasm_success: (a: number) => number;
+    readonly svelte2tsx: (a: number, b: number, c: number, d: number) => [number, number];
+    readonly version: () => [number, number];
+    readonly init: () => void;
+    readonly __wbindgen_free: (a: number, b: number, c: number) => void;
+    readonly __wbindgen_malloc: (a: number, b: number) => number;
+    readonly __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
+    readonly __wbindgen_externrefs: WebAssembly.Table;
+    readonly __wbindgen_start: () => void;
+}
+
+export type SyncInitInput = BufferSource | WebAssembly.Module;
+
+/**
+ * Instantiates the given `module`, which can either be bytes or
+ * a precompiled `WebAssembly.Module`.
+ *
+ * @param {{ module: SyncInitInput }} module - Passing `SyncInitInput` directly is deprecated.
+ *
+ * @returns {InitOutput}
+ */
+export function initSync(module: { module: SyncInitInput } | SyncInitInput): InitOutput;
+
+/**
+ * If `module_or_path` is {RequestInfo} or {URL}, makes a request and
+ * for everything else, calls `WebAssembly.instantiate` directly.
+ *
+ * @param {{ module_or_path: InitInput | Promise<InitInput> }} module_or_path - Passing `InitInput` directly is deprecated.
+ *
+ * @returns {Promise<InitOutput>}
+ */
+export default function __wbg_init (module_or_path?: { module_or_path: InitInput | Promise<InitInput> } | InitInput | Promise<InitInput>): Promise<InitOutput>;