@rusveltejs/compiler 0.0.0-stage → 0.1.0

package/LICENSE

@@ -0,0 +1,9 @@
+MIT License
+
+Copyright (c) 2026 rusvelte contributors
+
+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,3 +1,68 @@
-# Temporary Holding Version
+# @rusveltejs/compiler
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+The rusvelte compiler as a drop-in for `svelte/compiler` in Vite builds. vite-plugin-svelte and
+SvelteKit keep working as they are; their calls to `compile` and `compileModule` go to the Rust
+port instead, and get the same results the official compiler would return.
+
+Experimental. It reproduces Svelte 5.57.2; with any other version installed it steps aside and
+the official compiler does the work.
+
+## Use
+
+```sh
+npm install -D @rusveltejs/compiler
+```
+
+Prebuilt native modules cover macOS (arm64, x64), Linux (x64 and arm64 with glibc 2.17 or newer,
+x64 with musl) and Windows (x64). On any other platform the package warns and uses the official
+compiler. From a checkout of the repository instead:
+`cargo build --release -p rusvelte-node && node packages/rusvelte/build.js`.
+
+Then either load it for the whole process:
+
+```sh
+NODE_OPTIONS="--import @rusveltejs/compiler/register" vite build
+```
+
+or wrap the Svelte plugin in `vite.config`:
+
+```js
+import { rusvelte } from '@rusveltejs/compiler/vite';
+
+export default defineConfig({
+	plugins: [rusvelte(() => import('@sveltejs/kit/vite').then((m) => m.sveltekit()))]
+});
+```
+
+The import has to be dynamic, and nothing else in the config may import vite-plugin-svelte
+statically, or it binds the official compiler before rusvelte can step in.
+
+## What it does
+
+`register` adds a Node module hook: `svelte/compiler` resolves to a module that re-exports the
+installed compiler with `compile` and `compileModule` replaced. Those call the native module,
+then build the result with the installed compiler's own helpers (warnings with their frames,
+source map objects, merging of preprocessor maps), so results have the same shape and content.
+
+It falls back to the official compiler for:
+- any Svelte version other than the one this build reproduces (5.57.2);
+- options it doesn't implement, such as a `cssHash` function;
+- components that fail to compile, so errors are exactly Svelte's;
+- anything the native side can't handle.
+
+## Environment variables
+
+- `RUSVELTE_VERIFY=1`: also compile everything with the official compiler and report any
+  difference (slower; for checking a project).
+- `RUSVELTE_DEBUG=1`: report why a compilation fell back.
+- `RUSVELTE_NATIVE=/path/to/rusvelte.node`: use another build of the native module.
+- `RUSVELTE_ALLOW_VERSION_MISMATCH=1`: use rusvelte with other Svelte versions anyway. Its
+  output targets 5.57.2's runtime, so this can break your app.
+
+## Status
+
+- Identical results to `svelte/compiler`, source maps included, on 20,410 compilations of
+  real projects through this package (`oracle/check_rusvelte_package.mjs`), in the option
+  sets Vite uses.
+- Production `vite build` output identical to the official compiler's on the projects tried.
+- Preprocessors (`vitePreprocess`, PostCSS, ...) still run in JavaScript, as before.

package/THIRD_PARTY_NOTICES.md

@@ -0,0 +1,87 @@
+# Third-party notices
+
+rusvelte ports code from the following MIT-licensed projects. Their notices follow.
+
+## [Svelte](https://github.com/sveltejs/svelte)
+
+The parser, analysis and code generation are ports of `packages/svelte/src/compiler` (5.57.2); compiler messages and a11y data are generated from it.
+
+```
+Copyright (c) 2016-2025 [Svelte Contributors](https://github.com/sveltejs/svelte/graphs/contributors)
+
+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.
+```
+
+## [Svelte language tools](https://github.com/sveltejs/language-tools)
+
+svelte2tsx and svelte-check-rs are ports of `packages/svelte2tsx` and parts of `packages/svelte-check` and `packages/language-server`.
+
+```
+Copyright (c) 2020-Present [these people](https://github.com/sveltejs/language-tools/graphs/contributors) 
+
+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.
+```
+
+## [esrap](https://github.com/sveltejs/esrap)
+
+`src/estree/print.rs` is a port of esrap 2.4.0.
+
+```
+Copyright (c) 2023-2025 [these people](https://github.com/sveltejs/esrap/graphs/contributors)
+
+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.
+```
+
+## [magic-string](https://github.com/Rich-Harris/magic-string)
+
+`src/magic_string.rs` is a port of magic-string.
+
+```
+Copyright 2018 Rich Harris
+
+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.
+```
+
+## [vscode-css-languageservice](https://github.com/microsoft/vscode-css-languageservice)
+
+`src/css_lint/` is a port of its CSS/SCSS/LESS parsers and lint rules; `tools/gen_css_data.mjs` generates property data from it.
+
+```
+The MIT License (MIT)
+
+Copyright (c) Microsoft
+
+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/compiler.js

@@ -0,0 +1,296 @@
+// `compile` and `compileModule` backed by rusvelte, with the same results as `svelte/compiler`'s.
+// The pieces of the real compiler they need (its `state`, `CompileDiagnostic` and source map
+// helpers) are passed in by the generated module in register.js, so warnings and maps are
+// built by Svelte's own code. Anything rusvelte doesn't handle falls back to the real compiler:
+// other Svelte versions, unsupported options, compile errors (so their messages and frames
+// are Svelte's own) and internal failures.
+import * as native from './native.js';
+
+const debug = !!process.env.RUSVELTE_DEBUG;
+// `RUSVELTE_VERIFY=1` also runs the real compiler on every compilation and reports differences
+const verify = !!process.env.RUSVELTE_VERIFY;
+
+/** Counts of native compilations and fallbacks (by reason), for `RUSVELTE_DEBUG` and tests */
+export const stats = { native: 0, fallback: {} };
+
+/** @param {string} reason */
+function fell_back(reason) {
+	stats.fallback[reason] = (stats.fallback[reason] ?? 0) + 1;
+	if (debug && stats.fallback[reason] === 1) console.warn(`[rusvelte] falling back to svelte/compiler: ${reason}`);
+}
+
+// Options rusvelte implements, with the values it accepts (`undefined` is always fine).
+// Handled here rather than natively: `sourcemap`, `outputFilename`, `cssOutputFilename`,
+// `warningFilter` and `modernAst`.
+const COMPONENT_OPTIONS = {
+	filename: 'string',
+	generate: ['client', 'server'],
+	dev: 'boolean',
+	hmr: 'boolean',
+	css: ['external', 'injected'],
+	runes: 'boolean',
+	experimental: { async: 'boolean' },
+	accessors: 'boolean',
+	immutable: 'boolean',
+	customElement: 'boolean',
+	discloseVersion: 'boolean',
+	compatibility: { componentApi: [4, 5] },
+	namespace: ['html', 'svg', 'mathml'],
+	preserveComments: 'boolean',
+	preserveWhitespace: 'boolean',
+	fragments: ['html', 'tree'],
+	rootDir: 'string',
+	name: 'string',
+	sourcemap: 'any',
+	outputFilename: 'string',
+	cssOutputFilename: 'string',
+	warningFilter: 'function',
+	modernAst: 'boolean'
+};
+
+const MODULE_OPTIONS = {
+	filename: 'string',
+	generate: ['client', 'server'],
+	dev: 'boolean',
+	rootDir: 'string',
+	experimental: { async: 'boolean' },
+	warningFilter: 'function'
+};
+
+/**
+ * The first option rusvelte can't handle, or null
+ * @param {Record<string, any>} options
+ * @param {Record<string, any>} spec
+ * @param {string} [prefix]
+ * @returns {string | null}
+ */
+function unsupported_option(options, spec, prefix = '') {
+	for (const [key, value] of Object.entries(options)) {
+		if (value === undefined) continue;
+		const expected = spec[key];
+		const name = prefix + key;
+		if (expected === undefined) return name;
+		if (expected === 'any') continue;
+		if (Array.isArray(expected)) {
+			if (!expected.includes(value)) return `${name}: ${JSON.stringify(value)}`;
+		} else if (typeof expected === 'object') {
+			if (value === null || typeof value !== 'object') return name;
+			const inner = unsupported_option(value, expected, name + '.');
+			if (inner) return inner;
+		} else if (typeof value !== expected) {
+			return name;
+		}
+	}
+	return null;
+}
+
+/** Options as the native side reads them (functions and maps left out) */
+function native_options(options) {
+	const { sourcemap, warningFilter, outputFilename, cssOutputFilename, modernAst, ...rest } = options;
+	return JSON.stringify(rest);
+}
+
+/** `remove_bom` */
+function remove_bom(source) {
+	return source.charCodeAt(0) === 0xfeff ? source.slice(1) : source;
+}
+
+/** magic-string's `getRelativePath` */
+function get_relative_path(from, to) {
+	const from_parts = from.split(/[/\\]/);
+	const to_parts = to.split(/[/\\]/);
+	from_parts.pop();
+	while (from_parts[0] === to_parts[0]) {
+		from_parts.shift();
+		to_parts.shift();
+	}
+	if (from_parts.length) {
+		let i = from_parts.length;
+		while (i--) from_parts[i] = '..';
+	}
+	return from_parts.concat(to_parts).join('/');
+}
+
+/** esrap's `SourceMap` (same fields, in the same order) */
+class JsSourceMap {
+	version = 3;
+	names = [];
+
+	constructor(mappings, source_name, source) {
+		this.sources = [source_name || null];
+		this.sourcesContent = [source || null];
+		this.mappings = mappings;
+	}
+
+	toString() {
+		return JSON.stringify(this);
+	}
+
+	toUrl() {
+		return 'data:application/json;charset=utf-8;base64,' + Buffer.from(this.toString(), 'utf-8').toString('base64');
+	}
+}
+
+/**
+ * @param {{
+ *   real: typeof import('svelte/compiler'),
+ *   state: any,
+ *   CompileDiagnostic: any,
+ *   merge_with_preprocessor_map: Function,
+ *   get_source_name: Function,
+ *   MagicSourceMap: any
+ * }} svelte
+ */
+export function create(svelte) {
+	const { real, state, CompileDiagnostic, merge_with_preprocessor_map, get_source_name, MagicSourceMap } = svelte;
+
+	/** results rusvelte produced (not the real compiler) */
+	const native_results = new WeakSet();
+
+	class CompileWarning extends CompileDiagnostic {
+		name = 'CompileWarning';
+	}
+
+	if (!native.native) {
+		console.warn(`[rusvelte] ${native.load_error}; using svelte/compiler`);
+		return { compile: real.compile, compileModule: real.compileModule };
+	}
+
+	const version_ok = real.VERSION === native.svelteVersion || !!process.env.RUSVELTE_ALLOW_VERSION_MISMATCH;
+	if (!version_ok) {
+		console.warn(
+			`[rusvelte] svelte ${real.VERSION} is installed, but this rusvelte build reproduces svelte ${native.svelteVersion}; using svelte/compiler`
+		);
+	}
+
+	/**
+	 * Runs the native compiler; null means "use the real one"
+	 * @param {boolean} module
+	 */
+	function run(source, options, module) {
+		// `validate-options.js` defaults `rootDir` to the working directory
+		if (options.rootDir === undefined && typeof process !== 'undefined') options = { ...options, rootDir: process.cwd() };
+		if (!version_ok) return fell_back(`svelte ${real.VERSION}`), null;
+		const bad = unsupported_option(options, module ? MODULE_OPTIONS : COMPONENT_OPTIONS);
+		if (bad) return fell_back(`option ${bad}`), null;
+		const result = JSON.parse((module ? native.compileModule : native.compile)(source, native_options(options)));
+		if (result.unsupported) return fell_back(result.unsupported), null;
+		// let the real compiler throw, so the error is exactly Svelte's
+		if (result.error) return fell_back(`compile error ${result.error.code}`), null;
+		stats.native++;
+		return result;
+	}
+
+	/** `state` as compile leaves it, so `CompileDiagnostic` fills in filename, start/end, frame */
+	function set_state(source, options, runes) {
+		state.reset({ warning: options.warningFilter, filename: options.filename });
+		state.set_source(source);
+		state.adjust({ dev: !!options.dev, rootDir: options.rootDir ?? process.cwd(), runes });
+	}
+
+	function warnings_of(result, options) {
+		const filter = options.warningFilter ?? (() => true);
+		const out = [];
+		for (const w of result.warnings) {
+			const warning = new CompileWarning(w.code, w.message, w.position ?? undefined);
+			if (filter(warning)) out.push(warning);
+		}
+		return out;
+	}
+
+	/** Reports the first difference between our result and the real compiler's */
+	function check(kind, source, options, ours) {
+		const theirs = (kind === 'module' ? real.compileModule : real.compile)(source, options);
+		const pairs = [
+			['js', ours.js.code, theirs.js.code],
+			['css', ours.css?.code, theirs.css?.code],
+			['warnings', JSON.stringify(ours.warnings), JSON.stringify(theirs.warnings)]
+		];
+		for (const [what, a, b] of pairs) {
+			if (a === b) continue;
+			const al = (a ?? '').split('\n');
+			const bl = (b ?? '').split('\n');
+			let i = 0;
+			while (i < al.length && al[i] === bl[i]) i++;
+			const shown = Object.fromEntries(Object.entries(options).filter(([, v]) => typeof v !== 'function'));
+			console.warn(
+				`[rusvelte] ${what} differs for ${options.filename} with ${JSON.stringify({ ...shown, sourcemap: undefined })}\n  line ${i + 1}\n  svelte:   ${bl[i]}\n  rusvelte: ${al[i]}`
+			);
+			stats.verify_failures = (stats.verify_failures ?? 0) + 1;
+			return;
+		}
+	}
+
+	/** @type {typeof real.compile} */
+	function compile(source, options) {
+		const result = compile_native(source, options);
+		if (verify && native_results.has(result)) check('component', remove_bom(source), options, result);
+		return result;
+	}
+
+	/** @type {typeof real.compile} */
+	function compile_native(source, options) {
+		source = remove_bom(source);
+		const result = run(source, options, false);
+		if (!result) return real.compile(source, options);
+		set_state(source, options, result.runes);
+		// `validate_component_options` defaults the filename
+		options = { ...options, filename: options.filename ?? '(unknown)' };
+
+		const js_source_name = get_source_name(options.filename, options.outputFilename, 'input.svelte');
+		const js = { code: result.js.code, map: new JsSourceMap(result.js.mappings, js_source_name, source) };
+		merge_with_preprocessor_map(js, options, js_source_name);
+
+		let css = null;
+		if (result.css) {
+			const file = options.cssOutputFilename || options.filename;
+			const map = new MagicSourceMap({
+				file: file ? file.split(/[/\\]/).pop() : undefined,
+				sources: [options.filename ? get_relative_path(file || '', options.filename) : file || ''],
+				sourcesContent: [source],
+				names: [],
+				mappings: []
+			});
+			map.mappings = result.css.mappings;
+			css = { code: result.css.code, map, hasGlobal: result.css.hasGlobal };
+			merge_with_preprocessor_map(css, options, css.map.sources[0]);
+		}
+
+		const warnings = warnings_of(result, options);
+		let ast;
+		const compiled = {
+			js,
+			css,
+			warnings,
+			metadata: { runes: result.runes },
+			// parsed on demand: vite-plugin-svelte doesn't read it
+			get ast() {
+				return (ast ??= real.parse(source, { modern: !!options.modernAst, filename: options.filename }));
+			},
+			set ast(value) {
+				ast = value;
+			}
+		};
+		native_results.add(compiled);
+		return compiled;
+	}
+
+	/** @type {typeof real.compileModule} */
+	function compileModule(source, options) {
+		source = remove_bom(source);
+		const result = run(source, options, true);
+		if (!result) return real.compileModule(source, options);
+		set_state(source, options, true);
+		options = { ...options, filename: options.filename ?? '(unknown)' };
+		const js_source_name = get_source_name(options.filename, undefined, 'input.svelte.js');
+		return {
+			js: { code: result.js.code, map: new JsSourceMap(result.js.mappings, js_source_name, source) },
+			css: null,
+			warnings: warnings_of(result, options),
+			metadata: { runes: true },
+			ast: null
+		};
+	}
+
+	return { compile, compileModule };
+}

package/native.js

@@ -0,0 +1,43 @@
+// The native module: `compile(source, optionsJson)` and `compileModule(source, optionsJson)`
+// return JSON (see bindings/node/src/lib.rs). It comes from `RUSVELTE_NATIVE` if set, else a
+// local build (`rusvelte.node`, made by `npm run build`), else the prebuilt package for this
+// platform (`@rusveltejs/<platform>-<arch>[-<libc>]`, an optional dependency).
+import { createRequire } from 'node:module';
+import fs from 'node:fs';
+import { fileURLToPath } from 'node:url';
+
+const require = createRequire(import.meta.url);
+
+/** The suffix of this platform's prebuilt package */
+function platform_package() {
+	const { platform, arch } = process;
+	if (platform === 'linux') {
+		const glibc = process.report?.getReport?.().header?.glibcVersionRuntime;
+		return `@rusveltejs/linux-${arch}-${glibc ? 'gnu' : 'musl'}`;
+	}
+	if (platform === 'win32') return `@rusveltejs/win32-${arch}-msvc`;
+	return `@rusveltejs/${platform}-${arch}`;
+}
+
+function load() {
+	if (process.env.RUSVELTE_NATIVE) return require(process.env.RUSVELTE_NATIVE);
+	const local = fileURLToPath(new URL('./rusvelte.node', import.meta.url));
+	if (fs.existsSync(local)) return require(local);
+	return require(platform_package());
+}
+
+/** The native module, or null where there's none (compiler.js then uses svelte/compiler) */
+export let native = null;
+/** Why the native module couldn't be loaded */
+export let load_error = null;
+try {
+	native = load();
+} catch (e) {
+	const where = process.env.RUSVELTE_NATIVE ?? platform_package();
+	load_error = `no native module for ${process.platform}-${process.arch} (${where}): ${e.message.split('\n')[0]}`;
+}
+
+export const compile = native?.compile;
+export const compileModule = native?.compileModule;
+/** The Svelte version whose output this build reproduces */
+export const svelteVersion = native?.svelteVersion() ?? null;

package/package.json

@@ -1,6 +1,49 @@
 {
   "name": "@rusveltejs/compiler",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "description": "The Svelte 5 compiler ported to Rust, as a drop-in for svelte/compiler in Vite builds",
+  "keywords": [
+    "svelte",
+    "compiler",
+    "rust",
+    "vite",
+    "sveltekit",
+    "oxc"
+  ],
+  "homepage": "https://nihilist-narwhal.github.io/rusvelte/",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/nihilist-narwhal/rusvelte.git",
+    "directory": "packages/rusvelte"
+  },
+  "license": "MIT",
+  "type": "module",
+  "exports": {
+    ".": "./native.js",
+    "./register": "./register.js",
+    "./vite": "./vite.js"
+  },
+  "files": [
+    "native.js",
+    "compiler.js",
+    "register.js",
+    "vite.js",
+    "README.md",
+    "LICENSE",
+    "THIRD_PARTY_NOTICES.md"
+  ],
+  "engines": {
+    "node": ">=22.15"
+  },
+  "peerDependencies": {
+    "svelte": "^5.0.0"
+  },
+  "optionalDependencies": {
+    "@rusveltejs/darwin-arm64": "0.1.0",
+    "@rusveltejs/darwin-x64": "0.1.0",
+    "@rusveltejs/linux-x64-gnu": "0.1.0",
+    "@rusveltejs/linux-arm64-gnu": "0.1.0",
+    "@rusveltejs/linux-x64-musl": "0.1.0",
+    "@rusveltejs/win32-x64-msvc": "0.1.0"
+  }
+}

package/register.js

@@ -0,0 +1,52 @@
+// Makes `import ... from 'svelte/compiler'` (in vite-plugin-svelte, SvelteKit, anything loaded
+// after this) get a module that re-exports the installed svelte/compiler with `compile` and
+// `compileModule` replaced by rusvelte's (see compiler.js). Load it before those packages:
+//
+//   NODE_OPTIONS="--import @rusveltejs/compiler/register" vite build
+//
+// or call `register()` before importing them dynamically (vite.js does).
+import { registerHooks } from 'node:module';
+
+const PACKAGE = new URL('./', import.meta.url).href;
+const SHIM = new URL('./svelte-compiler.js', import.meta.url).href;
+const COMPILER = new URL('./compiler.js', import.meta.url).href;
+
+let registered = false;
+
+export function register() {
+	if (registered) return;
+	registered = true;
+	registerHooks({
+		resolve(specifier, context, next) {
+			const parent = context.parentURL ?? '';
+			// the generated module's own imports resolve from the real compiler's location
+			if (parent.startsWith(SHIM + '?')) {
+				const real = new URL(parent).searchParams.get('real');
+				return next(specifier, { ...context, parentURL: real });
+			}
+			if (specifier === 'svelte/compiler' && !parent.startsWith(PACKAGE) && context.conditions?.includes('import')) {
+				const real = next(specifier, context);
+				return { url: `${SHIM}?real=${encodeURIComponent(real.url)}`, format: 'module', shortCircuit: true };
+			}
+			return next(specifier, context);
+		},
+		load(url, context, next) {
+			if (!url.startsWith(SHIM + '?')) return next(url, context);
+			const real = new URL(url).searchParams.get('real');
+			const at = (path) => JSON.stringify(new URL(path, real).href);
+			const source = `
+export * from ${JSON.stringify(real)};
+import * as real from ${JSON.stringify(real)};
+import * as state from ${at('./state.js')};
+import { CompileDiagnostic } from ${at('./utils/compile_diagnostic.js')};
+import { merge_with_preprocessor_map, get_source_name } from ${at('./utils/mapped_code.js')};
+import { SourceMap as MagicSourceMap } from 'magic-string';
+import { create } from ${JSON.stringify(COMPILER)};
+export const { compile, compileModule } = create({ real, state, CompileDiagnostic, merge_with_preprocessor_map, get_source_name, MagicSourceMap });
+`;
+			return { format: 'module', source, shortCircuit: true };
+		}
+	});
+}
+
+register();

package/vite.js

@@ -0,0 +1,23 @@
+// Use rusvelte from vite.config without NODE_OPTIONS: wrap the import of the Svelte plugin so it
+// happens after the `svelte/compiler` hook is registered.
+//
+//   import { rusvelte } from '@rusveltejs/compiler/vite';
+//   export default defineConfig({
+//     plugins: [rusvelte(() => import('@sveltejs/kit/vite').then((m) => m.sveltekit()))]
+//   });
+//
+// (or `import('@sveltejs/vite-plugin-svelte').then((m) => m.svelte())`). The import must be
+// dynamic: a static import of vite-plugin-svelte anywhere in the config (vitePreprocess, say)
+// binds the real compiler before the hook exists. Vite accepts a promise of plugins.
+import { register } from './register.js';
+export { stats } from './compiler.js';
+
+/**
+ * @template T
+ * @param {() => Promise<T>} load
+ * @returns {Promise<T>}
+ */
+export function rusvelte(load) {
+	register();
+	return load();
+}