diff --git a/.changeset/young-feet-double.md b/.changeset/young-feet-double.md
new file mode 100644
index 000000000000..c1de0a948c1a
--- /dev/null
+++ b/.changeset/young-feet-double.md
@@ -0,0 +1,5 @@
+---
+'svelte': patch
+---
+
+feat: provide AST node types with internal types stripped out
diff --git a/packages/svelte/scripts/generate-types.js b/packages/svelte/scripts/generate-types.js
index ed9009df6a22..7678ed35b1c9 100644
--- a/packages/svelte/scripts/generate-types.js
+++ b/packages/svelte/scripts/generate-types.js
@@ -21,6 +21,10 @@ fs.writeFileSync(`${dir}/types/compiler/interfaces.d.ts`, "import '../index.js';
 
 await createBundle({
 	output: `${dir}/types/index.d.ts`,
+	compilerOptions: {
+		// so that types/properties with `@internal` (and its dependencies) are removed from the output
+		stripInternal: true
+	},
 	modules: {
 		[pkg.name]: `${dir}/src/index.d.ts`,
 		[`${pkg.name}/action`]: `${dir}/src/action/public.d.ts`,
diff --git a/packages/svelte/src/compiler/index.js b/packages/svelte/src/compiler/index.js
index e18c3c2ec3fb..88cc9880ee4d 100644
--- a/packages/svelte/src/compiler/index.js
+++ b/packages/svelte/src/compiler/index.js
@@ -90,7 +90,7 @@ export function compileModule(source, options) {
  * @overload
  * @param {string} source
  * @param {{ filename?: string; modern?: false }} [options]
- * @returns {LegacyRoot}
+ * @returns {Record<string, any>}
  */
 
 /**
@@ -102,7 +102,7 @@ export function compileModule(source, options) {
  * https://svelte.dev/docs/svelte-compiler#svelte-parse
  * @param {string} source
  * @param {{ filename?: string; rootDir?: string; modern?: boolean }} [options]
- * @returns {Root | LegacyRoot}
+ * @returns {Root | Record<string, any>}
  */
 export function parse(source, { filename, rootDir, modern } = {}) {
 	state.reset_warning_filter(() => false);
diff --git a/packages/svelte/src/compiler/public.d.ts b/packages/svelte/src/compiler/public.d.ts
index b7bd39200127..ec7d0be9a62a 100644
--- a/packages/svelte/src/compiler/public.d.ts
+++ b/packages/svelte/src/compiler/public.d.ts
@@ -12,3 +12,43 @@ export type {
 	CompileResult,
 	Warning
 } from './types/index';
+
+export type {
+	AnimateDirective,
+	Attribute,
+	AwaitBlock,
+	BindDirective,
+	ClassDirective,
+	Comment,
+	Component,
+	ConstTag,
+	DebugTag,
+	EachBlock,
+	ExpressionTag,
+	Fragment,
+	HtmlTag,
+	IfBlock,
+	KeyBlock,
+	LetDirective,
+	OnDirective,
+	RegularElement,
+	RenderTag,
+	Root,
+	Script,
+	SlotElement,
+	StyleDirective,
+	SvelteBody,
+	SvelteComponent,
+	SvelteDocument,
+	SvelteElement,
+	SvelteFragment,
+	SvelteHead,
+	SvelteWindow,
+	SvelteSelf,
+	SnippetBlock,
+	SpreadAttribute,
+	Text,
+	TitleElement,
+	TransitionDirective,
+	UseDirective
+} from './types/template';
diff --git a/packages/svelte/src/compiler/types/template.d.ts b/packages/svelte/src/compiler/types/template.d.ts
index a4480ce2f12b..74ce5659c24a 100644
--- a/packages/svelte/src/compiler/types/template.d.ts
+++ b/packages/svelte/src/compiler/types/template.d.ts
@@ -22,13 +22,14 @@ export interface BaseNode {
 	type: string;
 	start: number;
 	end: number;
-	/** This is set during parsing on elements/components/expressions/text (but not attributes etc) */
+	/** @internal This is set during parsing on elements/components/expressions/text (but not attributes etc) */
 	parent: SvelteNode | null;
 }
 
 export interface Fragment {
 	type: 'Fragment';
 	nodes: Array<Text | Tag | ElementLike | Block | Comment>;
+	/** @internal */
 	metadata: {
 		/**
 		 * Fragments declare their own scopes. A transparent fragment is one whose scope
@@ -63,6 +64,7 @@ export interface Root extends BaseNode {
 	instance: Script | null;
 	/** The parsed `<script module>` element, if exists */
 	module: Script | null;
+	/** @internal */
 	metadata: {
 		/** Whether the component was parsed with typescript */
 		ts: boolean;
@@ -115,6 +117,7 @@ export interface Text extends BaseNode {
 export interface ExpressionTag extends BaseNode {
 	type: 'ExpressionTag';
 	expression: Expression;
+	/** @internal */
 	metadata: {
 		expression: ExpressionMetadata;
 	};
@@ -152,6 +155,7 @@ export interface DebugTag extends BaseNode {
 export interface RenderTag extends BaseNode {
 	type: 'RenderTag';
 	expression: SimpleCallExpression | (ChainExpression & { expression: SimpleCallExpression });
+	/** @internal */
 	metadata: {
 		dynamic: boolean;
 		args_with_call_expression: Set<number>;
@@ -161,7 +165,7 @@ export interface RenderTag extends BaseNode {
 type Tag = ExpressionTag | HtmlTag | ConstTag | DebugTag | RenderTag;
 
 /** An `animate:` directive */
-interface AnimateDirective extends BaseNode {
+export interface AnimateDirective extends BaseNode {
 	type: 'AnimateDirective';
 	/** The 'x' in `animate:x` */
 	name: string;
@@ -176,6 +180,7 @@ export interface BindDirective extends BaseNode {
 	name: string;
 	/** The y in `bind:x={y}` */
 	expression: Identifier | MemberExpression;
+	/** @internal */
 	metadata: {
 		binding_group_name: Identifier;
 		parent_each_blocks: EachBlock[];
@@ -189,6 +194,7 @@ export interface ClassDirective extends BaseNode {
 	name: 'class';
 	/** The 'y' in `class:x={y}`, or the `x` in `class:x` */
 	expression: Expression;
+	/** @internal */
 	metadata: {
 		expression: ExpressionMetadata;
 	};
@@ -211,6 +217,7 @@ export interface OnDirective extends BaseNode {
 	/** The 'y' in `on:x={y}` */
 	expression: null | Expression;
 	modifiers: string[]; // TODO specify
+	/** @internal */
 	metadata: {
 		expression: ExpressionMetadata;
 	};
@@ -231,6 +238,7 @@ export interface StyleDirective extends BaseNode {
 	/** The 'y' in `style:x={y}` */
 	value: true | ExpressionTag | Array<ExpressionTag | Text>;
 	modifiers: Array<'important'>;
+	/** @internal */
 	metadata: {
 		expression: ExpressionMetadata;
 	};
@@ -238,7 +246,7 @@ export interface StyleDirective extends BaseNode {
 
 // TODO have separate in/out/transition directives
 /** A `transition:`, `in:` or `out:` directive */
-interface TransitionDirective extends BaseNode {
+export interface TransitionDirective extends BaseNode {
 	type: 'TransitionDirective';
 	/** The 'x' in `transition:x` */
 	name: string;
@@ -252,7 +260,7 @@ interface TransitionDirective extends BaseNode {
 }
 
 /** A `use:` directive */
-interface UseDirective extends BaseNode {
+export interface UseDirective extends BaseNode {
 	type: 'UseDirective';
 	/** The 'x' in `use:x` */
 	name: string;
@@ -278,13 +286,14 @@ interface BaseElement extends BaseNode {
 
 export interface Component extends BaseElement {
 	type: 'Component';
+	/** @internal */
 	metadata: {
 		scopes: Record<string, Scope>;
 		dynamic: boolean;
 	};
 }
 
-interface TitleElement extends BaseElement {
+export interface TitleElement extends BaseElement {
 	type: 'TitleElement';
 	name: 'title';
 }
@@ -296,6 +305,7 @@ export interface SlotElement extends BaseElement {
 
 export interface RegularElement extends BaseElement {
 	type: 'RegularElement';
+	/** @internal */
 	metadata: {
 		/** `true` if this is an svg element */
 		svg: boolean;
@@ -307,7 +317,7 @@ export interface RegularElement extends BaseElement {
 	};
 }
 
-interface SvelteBody extends BaseElement {
+export interface SvelteBody extends BaseElement {
 	type: 'SvelteBody';
 	name: 'svelte:body';
 }
@@ -316,12 +326,13 @@ export interface SvelteComponent extends BaseElement {
 	type: 'SvelteComponent';
 	name: 'svelte:component';
 	expression: Expression;
+	/** @internal */
 	metadata: {
 		scopes: Record<string, Scope>;
 	};
 }
 
-interface SvelteDocument extends BaseElement {
+export interface SvelteDocument extends BaseElement {
 	type: 'SvelteDocument';
 	name: 'svelte:document';
 }
@@ -330,6 +341,7 @@ export interface SvelteElement extends BaseElement {
 	type: 'SvelteElement';
 	name: 'svelte:element';
 	tag: Expression;
+	/** @internal */
 	metadata: {
 		/**
 		 * `true` if this is an svg element. The boolean may not be accurate because
@@ -350,7 +362,7 @@ export interface SvelteFragment extends BaseElement {
 	name: 'svelte:fragment';
 }
 
-interface SvelteHead extends BaseElement {
+export interface SvelteHead extends BaseElement {
 	type: 'SvelteHead';
 	name: 'svelte:head';
 }
@@ -364,12 +376,13 @@ export interface SvelteOptionsRaw extends BaseElement {
 export interface SvelteSelf extends BaseElement {
 	type: 'SvelteSelf';
 	name: 'svelte:self';
+	/** @internal */
 	metadata: {
 		scopes: Record<string, Scope>;
 	};
 }
 
-interface SvelteWindow extends BaseElement {
+export interface SvelteWindow extends BaseElement {
 	type: 'SvelteWindow';
 	name: 'svelte:window';
 }
@@ -398,6 +411,7 @@ export interface EachBlock extends BaseNode {
 	fallback?: Fragment;
 	index?: string;
 	key?: Expression;
+	/** @internal */
 	metadata: {
 		expression: ExpressionMetadata;
 		keyed: boolean;
@@ -458,6 +472,7 @@ export interface Attribute extends BaseNode {
 	type: 'Attribute';
 	name: string;
 	value: true | ExpressionTag | Array<Text | ExpressionTag>;
+	/** @internal */
 	metadata: {
 		expression: ExpressionMetadata;
 		/** May be set if this is an event attribute */
@@ -468,6 +483,7 @@ export interface Attribute extends BaseNode {
 export interface SpreadAttribute extends BaseNode {
 	type: 'SpreadAttribute';
 	expression: Expression;
+	/** @internal */
 	metadata: {
 		expression: ExpressionMetadata;
 	};
diff --git a/packages/svelte/types/index.d.ts b/packages/svelte/types/index.d.ts
index 09e9a23888c0..9c3be7ebfd58 100644
--- a/packages/svelte/types/index.d.ts
+++ b/packages/svelte/types/index.d.ts
@@ -582,7 +582,7 @@ declare module 'svelte/animate' {
 }
 
 declare module 'svelte/compiler' {
-	import type { AssignmentExpression, ClassDeclaration, Expression, FunctionDeclaration, Identifier, ImportDeclaration, ArrayExpression, MemberExpression, ObjectExpression, Pattern, Node, VariableDeclarator, ArrowFunctionExpression, VariableDeclaration, FunctionExpression, Program, ChainExpression, SimpleCallExpression } from 'estree';
+	import type { Expression, Identifier, ArrayExpression, ArrowFunctionExpression, VariableDeclaration, VariableDeclarator, MemberExpression, ObjectExpression, Pattern, Program, ChainExpression, SimpleCallExpression } from 'estree';
 	import type { SourceMap } from 'magic-string';
 	import type { Location } from 'locate-character';
 	/**
@@ -623,7 +623,7 @@ declare module 'svelte/compiler' {
 	export function parse(source: string, options?: {
 		filename?: string;
 		modern?: false;
-	} | undefined): LegacyRoot;
+	} | undefined): Record<string, any>;
 	/**
 	 * @deprecated Replace this with `import { walk } from 'estree-walker'`
 	 * */
@@ -896,608 +896,15 @@ declare module 'svelte/compiler' {
 		 */
 		warningFilter?: (warning: Warning) => boolean;
 	}
-
-	type DeclarationKind =
-		| 'var'
-		| 'let'
-		| 'const'
-		| 'function'
-		| 'import'
-		| 'param'
-		| 'rest_param'
-		| 'synthetic';
-
-	interface Binding {
-		node: Identifier;
-		/**
-		 * - `normal`: A variable that is not in any way special
-		 * - `prop`: A normal prop (possibly reassigned or mutated)
-		 * - `bindable_prop`: A prop one can `bind:` to (possibly reassigned or mutated)
-		 * - `rest_prop`: A rest prop
-		 * - `state`: A state variable
-		 * - `derived`: A derived variable
-		 * - `each`: An each block parameter
-		 * - `snippet`: A snippet parameter
-		 * - `store_sub`: A $store value
-		 * - `legacy_reactive`: A `$:` declaration
-		 */
-		kind:
-			| 'normal'
-			| 'prop'
-			| 'bindable_prop'
-			| 'rest_prop'
-			| 'state'
-			| 'raw_state'
-			| 'derived'
-			| 'each'
-			| 'snippet'
-			| 'store_sub'
-			| 'legacy_reactive';
-		declaration_kind: DeclarationKind;
-		/**
-		 * What the value was initialized with.
-		 * For destructured props such as `let { foo = 'bar' } = $props()` this is `'bar'` and not `$props()`
-		 */
-		initial:
-			| null
-			| Expression
-			| FunctionDeclaration
-			| ClassDeclaration
-			| ImportDeclaration
-			| EachBlock;
-		is_called: boolean;
-		references: { node: Identifier; path: SvelteNode[] }[];
-		mutated: boolean;
-		reassigned: boolean;
-		/** `true` if mutated _or_ reassigned */
-		updated: boolean;
-		scope: Scope;
-		/** For `legacy_reactive`: its reactive dependencies */
-		legacy_dependencies: Binding[];
-		/** Legacy props: the `class` in `{ export klass as class}`. $props(): The `class` in { class: klass } = $props() */
-		prop_alias: string | null;
-		/** Additional metadata, varies per binding type */
-		metadata: {
-			/** `true` if is (inside) a rest parameter */
-			inside_rest?: boolean;
-		} | null;
-	}
-
-	interface ExpressionMetadata {
-		/** All the bindings that are referenced inside this expression */
-		dependencies: Set<Binding>;
-		/** True if the expression references state directly, or _might_ (via member/call expressions) */
-		has_state: boolean;
-		/** True if the expression involves a call expression (often, it will need to be wrapped in a derived) */
-		has_call: boolean;
-	}
-	/**
-	 * The preprocess function provides convenient hooks for arbitrarily transforming component source code.
-	 * For example, it can be used to convert a <style lang="sass"> block into vanilla CSS.
-	 *
-	 * https://svelte.dev/docs/svelte-compiler#svelte-preprocess
-	 * */
-	export function preprocess(source: string, preprocessor: PreprocessorGroup | PreprocessorGroup[], options?: {
-		filename?: string;
-	} | undefined): Promise<Processed>;
-	/**
-	 * The current version, as set in package.json.
-	 *
-	 * https://svelte.dev/docs/svelte-compiler#svelte-version
-	 * */
-	export const VERSION: string;
-	/**
-	 * Does a best-effort migration of Svelte code towards using runes, event attributes and render tags.
-	 * May throw an error if the code is too complex to migrate automatically.
-	 *
-	 * */
-	export function migrate(source: string): {
-		code: string;
-	};
-	interface BaseNode_1 {
-		type: string;
-		start: number;
-		end: number;
-	}
-
-	interface BaseElement_1 extends BaseNode_1 {
-		name: string;
-		attributes: Array<LegacyAttributeLike>;
-		children: Array<LegacyElementLike>;
-	}
-
-	interface LegacyRoot extends BaseNode_1 {
-		html: LegacySvelteNode;
-		css?: any;
-		instance?: any;
-		module?: any;
-	}
-
-	interface LegacyAction extends BaseNode_1 {
-		type: 'Action';
-		/** The 'x' in `use:x` */
-		name: string;
-		/** The 'y' in `use:x={y}` */
-		expression: null | Expression;
-	}
-
-	interface LegacyAnimation extends BaseNode_1 {
-		type: 'Animation';
-		/** The 'x' in `animate:x` */
-		name: string;
-		/** The y in `animate:x={y}` */
-		expression: null | Expression;
-	}
-
-	interface LegacyBinding extends BaseNode_1 {
-		type: 'Binding';
-		/** The 'x' in `bind:x` */
-		name: string;
-		/** The y in `bind:x={y}` */
-		expression: Identifier | MemberExpression;
-	}
-
-	interface LegacyBody extends BaseElement_1 {
-		type: 'Body';
-		name: 'svelte:body';
-	}
-
-	interface LegacyAttribute extends BaseNode_1 {
-		type: 'Attribute';
-		name: string;
-		value: true | Array<Text | LegacyMustacheTag | LegacyAttributeShorthand>;
-	}
-
-	interface LegacyAttributeShorthand extends BaseNode_1 {
-		type: 'AttributeShorthand';
-		expression: Expression;
-	}
-
-	interface LegacyLet extends BaseNode_1 {
-		type: 'Let';
-		/** The 'x' in `let:x` */
-		name: string;
-		/** The 'y' in `let:x={y}` */
-		expression: null | Identifier | ArrayExpression | ObjectExpression;
-	}
-
-	interface LegacyCatchBlock extends BaseNode_1 {
-		type: 'CatchBlock';
-		children: LegacySvelteNode[];
-		skip: boolean;
-	}
-
-	interface LegacyClass extends BaseNode_1 {
-		type: 'Class';
-		/** The 'x' in `class:x` */
-		name: 'class';
-		/** The 'y' in `class:x={y}`, or the `x` in `class:x` */
-		expression: Expression;
-	}
-
-	interface LegacyDocument extends BaseElement_1 {
-		type: 'Document';
-	}
-
-	interface LegacyElement {
-		type: 'Element';
-	}
-
-	interface LegacyEventHandler extends BaseNode_1 {
-		type: 'EventHandler';
-		/** The 'x' in `on:x` */
-		name: string;
-		/** The 'y' in `on:x={y}` */
-		expression: null | Expression;
-		modifiers: string[];
-	}
-
-	interface LegacyHead extends BaseElement_1 {
-		type: 'Head';
-	}
-
-	interface LegacyInlineComponent extends BaseElement_1 {
-		type: 'InlineComponent';
-		/** Set if this is a `<svelte:component>` */
-		expression?: Expression;
-	}
-
-	interface LegacyMustacheTag extends BaseNode_1 {
-		type: 'MustacheTag';
-		expression: Expression;
-	}
-
-	interface LegacyOptions {
-		type: 'Options';
-		name: 'svelte:options';
-		attributes: Array<any>;
-	}
-
-	interface LegacyPendingBlock extends BaseNode_1 {
-		type: 'PendingBlock';
-		children: LegacySvelteNode[];
-		skip: boolean;
-	}
-
-	interface LegacyRawMustacheTag extends BaseNode_1 {
-		type: 'RawMustacheTag';
-		expression: Expression;
-	}
-
-	interface LegacySpread extends BaseNode_1 {
-		type: 'Spread';
-		expression: Expression;
-	}
-
-	interface LegacySlot extends BaseElement_1 {
-		type: 'Slot';
-	}
-
-	interface LegacySlotTemplate extends BaseElement_1 {
-		type: 'SlotTemplate';
-	}
-
-	interface LegacyThenBlock extends BaseNode_1 {
-		type: 'ThenBlock';
-		children: LegacySvelteNode[];
-		skip: boolean;
-	}
-
-	interface LegacyTitle extends BaseElement_1 {
-		type: 'Title';
-		name: 'title';
-	}
-
-	interface LegacyConstTag extends BaseNode_1 {
-		type: 'ConstTag';
-		expression: AssignmentExpression;
-	}
-
-	interface LegacyTransition extends BaseNode_1 {
-		type: 'Transition';
-		/** The 'x' in `transition:x` */
-		name: string;
-		/** The 'y' in `transition:x={y}` */
-		expression: null | Expression;
-		modifiers: Array<'local' | 'global'>;
-		/** True if this is a `transition:` or `in:` directive */
-		intro: boolean;
-		/** True if this is a `transition:` or `out:` directive */
-		outro: boolean;
-	}
-
-	/** A `style:` directive */
-	interface LegacyStyleDirective extends BaseNode_1 {
-		type: 'StyleDirective';
-		/** The 'x' in `style:x` */
-		name: string;
-		/** The 'y' in `style:x={y}` */
-		value: true | Array<ExpressionTag | Text>;
-		modifiers: Array<'important'>;
-	}
-
-	interface LegacyWindow extends BaseElement_1 {
-		type: 'Window';
-	}
-
-	interface LegacyComment extends BaseNode_1 {
-		type: 'Comment';
-		/** the contents of the comment */
-		data: string;
-		/** any svelte-ignore directives — <!-- svelte-ignore a b c --> would result in ['a', 'b', 'c'] */
-		ignores: string[];
-	}
-
-	type LegacyDirective =
-		| LegacyAnimation
-		| LegacyBinding
-		| LegacyClass
-		| LegacyLet
-		| LegacyEventHandler
-		| LegacyStyleDirective
-		| LegacyTransition
-		| LegacyAction;
-
-	type LegacyAttributeLike = LegacyAttribute | LegacySpread | LegacyDirective;
-
-	type LegacyElementLike =
-		| LegacyBody
-		| LegacyCatchBlock
-		| LegacyComment
-		| LegacyDocument
-		| LegacyElement
-		| LegacyHead
-		| LegacyInlineComponent
-		| LegacyMustacheTag
-		| LegacyOptions
-		| LegacyPendingBlock
-		| LegacyRawMustacheTag
-		| LegacySlot
-		| LegacySlotTemplate
-		| LegacyThenBlock
-		| LegacyTitle
-		| LegacyWindow;
-
-	interface LegacyStyle extends BaseNode_1 {
-		type: 'Style';
-		attributes: any[];
-		content: {
-			start: number;
-			end: number;
-			styles: string;
-		};
-		children: any[];
-	}
-
-	interface LegacySelector extends BaseNode_1 {
-		type: 'Selector';
-		children: Array<Css.Combinator | Css.SimpleSelector>;
-	}
-
-	type LegacyCssNode = LegacyStyle | LegacySelector;
-
-	type LegacySvelteNode =
-		| LegacyConstTag
-		| LegacyElementLike
-		| LegacyAttributeLike
-		| LegacyAttributeShorthand
-		| LegacyCssNode
-		| Text;
-	class Scope {
-		
-		constructor(root: ScopeRoot, parent: Scope | null, porous: boolean);
-		
-		root: ScopeRoot;
-		/**
-		 * The immediate parent scope
-		 * */
-		parent: Scope | null;
-		/**
-		 * A map of every identifier declared by this scope, and all the
-		 * identifiers that reference it
-		 * */
-		declarations: Map<string, Binding>;
-		/**
-		 * A map of declarators to the bindings they declare
-		 * */
-		declarators: Map<VariableDeclarator | LetDirective, Binding[]>;
-		/**
-		 * A set of all the names referenced with this scope
-		 * — useful for generating unique names
-		 * */
-		references: Map<string, {
-			node: Identifier;
-			path: SvelteNode[];
-		}[]>;
-		/**
-		 * The scope depth allows us to determine if a state variable is referenced in its own scope,
-		 * which is usually an error. Block statements do not increase this value
-		 */
-		function_depth: number;
-		
-		declare(node: Identifier, kind: Binding["kind"], declaration_kind: DeclarationKind, initial?: null | Expression | FunctionDeclaration | ClassDeclaration | ImportDeclaration | EachBlock): Binding;
-		child(porous?: boolean): Scope;
-		
-		generate(preferred_name: string): string;
-		
-		get(name: string): Binding | null;
-		
-		get_bindings(node: VariableDeclarator | LetDirective): Binding[];
-		
-		owner(name: string): Scope | null;
-		
-		reference(node: Identifier, path: SvelteNode[]): void;
-		#private;
-	}
-	class ScopeRoot {
-		
-		conflicts: Set<string>;
-		
-		unique(preferred_name: string): Identifier;
-	}
-	namespace Css {
-		export interface BaseNode {
-			start: number;
-			end: number;
-		}
-
-		export interface StyleSheet extends BaseNode {
-			type: 'StyleSheet';
-			attributes: any[]; // TODO
-			children: Array<Atrule | Rule>;
-			content: {
-				start: number;
-				end: number;
-				styles: string;
-				/** Possible comment atop the style tag */
-				comment: Comment | null;
-			};
-		}
-
-		export interface Atrule extends BaseNode {
-			type: 'Atrule';
-			name: string;
-			prelude: string;
-			block: Block | null;
-		}
-
-		export interface Rule extends BaseNode {
-			type: 'Rule';
-			prelude: SelectorList;
-			block: Block;
-			metadata: {
-				parent_rule: null | Rule;
-				has_local_selectors: boolean;
-				/**
-				 * `true` if the rule contains a `:global` selector, and therefore everything inside should be unscoped
-				 */
-				is_global_block: boolean;
-			};
-		}
-
-		/**
-		 * A list of selectors, e.g. `a, b, c {}`
-		 */
-		export interface SelectorList extends BaseNode {
-			type: 'SelectorList';
-			/**
-			 * The `a`, `b` and `c` in `a, b, c {}`
-			 */
-			children: ComplexSelector[];
-		}
-
-		/**
-		 * A complex selector, e.g. `a b c {}`
-		 */
-		export interface ComplexSelector extends BaseNode {
-			type: 'ComplexSelector';
-			/**
-			 * The `a`, `b` and `c` in `a b c {}`
-			 */
-			children: RelativeSelector[];
-			metadata: {
-				rule: null | Rule;
-				used: boolean;
-			};
-		}
-
-		/**
-		 * A relative selector, e.g the `a` and `> b` in `a > b {}`
-		 */
-		export interface RelativeSelector extends BaseNode {
-			type: 'RelativeSelector';
-			/**
-			 * In `a > b`, `> b` forms one relative selector, and `>` is the combinator. `null` for the first selector.
-			 */
-			combinator: null | Combinator;
-			/**
-			 * The `b:is(...)` in `> b:is(...)`
-			 */
-			selectors: SimpleSelector[];
-			metadata: {
-				/**
-				 * `true` if the whole selector is unscoped, e.g. `:global(...)` or `:global` or `:global.x`.
-				 * Selectors like `:global(...).x` are not considered global, because they still need scoping.
-				 */
-				is_global: boolean;
-				/** `:root`, `:host`, `::view-transition`, or selectors after a `:global` */
-				is_global_like: boolean;
-				scoped: boolean;
-			};
-		}
-
-		export interface TypeSelector extends BaseNode {
-			type: 'TypeSelector';
-			name: string;
-		}
-
-		export interface IdSelector extends BaseNode {
-			type: 'IdSelector';
-			name: string;
-		}
-
-		export interface ClassSelector extends BaseNode {
-			type: 'ClassSelector';
-			name: string;
-		}
-
-		export interface AttributeSelector extends BaseNode {
-			type: 'AttributeSelector';
-			name: string;
-			matcher: string | null;
-			value: string | null;
-			flags: string | null;
-		}
-
-		export interface PseudoElementSelector extends BaseNode {
-			type: 'PseudoElementSelector';
-			name: string;
-		}
-
-		export interface PseudoClassSelector extends BaseNode {
-			type: 'PseudoClassSelector';
-			name: string;
-			args: SelectorList | null;
-		}
-
-		export interface Percentage extends BaseNode {
-			type: 'Percentage';
-			value: string;
-		}
-
-		export interface NestingSelector extends BaseNode {
-			type: 'NestingSelector';
-			name: '&';
-		}
-
-		export interface Nth extends BaseNode {
-			type: 'Nth';
-			value: string;
-		}
-
-		export type SimpleSelector =
-			| TypeSelector
-			| IdSelector
-			| ClassSelector
-			| AttributeSelector
-			| PseudoElementSelector
-			| PseudoClassSelector
-			| Percentage
-			| Nth
-			| NestingSelector;
-
-		export interface Combinator extends BaseNode {
-			type: 'Combinator';
-			name: string;
-		}
-
-		export interface Block extends BaseNode {
-			type: 'Block';
-			children: Array<Declaration | Rule | Atrule>;
-		}
-
-		export interface Declaration extends BaseNode {
-			type: 'Declaration';
-			property: string;
-			value: string;
-		}
-
-		// for zimmerframe
-		export type Node =
-			| StyleSheet
-			| Rule
-			| Atrule
-			| SelectorList
-			| Block
-			| ComplexSelector
-			| RelativeSelector
-			| Combinator
-			| SimpleSelector
-			| Declaration;
-	}
 	interface BaseNode {
 		type: string;
 		start: number;
 		end: number;
-		/** This is set during parsing on elements/components/expressions/text (but not attributes etc) */
-		parent: SvelteNode | null;
 	}
 
-	interface Fragment {
+	export interface Fragment {
 		type: 'Fragment';
 		nodes: Array<Text | Tag | ElementLike | Block | Comment>;
-		metadata: {
-			/**
-			 * Fragments declare their own scopes. A transparent fragment is one whose scope
-			 * is not represented by a scope in the resulting JavaScript (e.g. an element scope),
-			 * and should therefore delegate to parent scopes when generating unique identifiers
-			 */
-			transparent: boolean;
-			/**
-			 * Whether or not we need to traverse into the fragment during mount/hydrate
-			 */
-			dynamic: boolean;
-		};
 	}
 
 	/**
@@ -1507,7 +914,7 @@ declare module 'svelte/compiler' {
 	 */
 	type Namespace = 'html' | 'svg' | 'mathml';
 
-	interface Root extends BaseNode {
+	export interface Root extends BaseNode {
 		type: 'Root';
 		/**
 		 * Inline options provided by `<svelte:options>` — these override options passed to `compile(...)`
@@ -1520,10 +927,6 @@ declare module 'svelte/compiler' {
 		instance: Script | null;
 		/** The parsed `<script module>` element, if exists */
 		module: Script | null;
-		metadata: {
-			/** Whether the component was parsed with typescript */
-			ts: boolean;
-		};
 	}
 
 	interface SvelteOptions {
@@ -1560,7 +963,7 @@ declare module 'svelte/compiler' {
 	}
 
 	/** Static text */
-	interface Text extends BaseNode {
+	export interface Text extends BaseNode {
 		type: 'Text';
 		/** Text with decoded HTML entities */
 		data: string;
@@ -1569,30 +972,27 @@ declare module 'svelte/compiler' {
 	}
 
 	/** A (possibly reactive) template expression — `{...}` */
-	interface ExpressionTag extends BaseNode {
+	export interface ExpressionTag extends BaseNode {
 		type: 'ExpressionTag';
 		expression: Expression;
-		metadata: {
-			expression: ExpressionMetadata;
-		};
 	}
 
 	/** A (possibly reactive) HTML template expression — `{@html ...}` */
-	interface HtmlTag extends BaseNode {
+	export interface HtmlTag extends BaseNode {
 		type: 'HtmlTag';
 		expression: Expression;
 	}
 
 	/** An HTML comment */
 	// TODO rename to disambiguate
-	interface Comment extends BaseNode {
+	export interface Comment extends BaseNode {
 		type: 'Comment';
 		/** the contents of the comment */
 		data: string;
 	}
 
 	/** A `{@const ...}` tag */
-	interface ConstTag extends BaseNode {
+	export interface ConstTag extends BaseNode {
 		type: 'ConstTag';
 		declaration: VariableDeclaration & {
 			declarations: [VariableDeclarator & { id: Pattern; init: Expression }];
@@ -1600,25 +1000,21 @@ declare module 'svelte/compiler' {
 	}
 
 	/** A `{@debug ...}` tag */
-	interface DebugTag extends BaseNode {
+	export interface DebugTag extends BaseNode {
 		type: 'DebugTag';
 		identifiers: Identifier[];
 	}
 
 	/** A `{@render foo(...)} tag */
-	interface RenderTag extends BaseNode {
+	export interface RenderTag extends BaseNode {
 		type: 'RenderTag';
 		expression: SimpleCallExpression | (ChainExpression & { expression: SimpleCallExpression });
-		metadata: {
-			dynamic: boolean;
-			args_with_call_expression: Set<number>;
-		};
 	}
 
 	type Tag = ExpressionTag | HtmlTag | ConstTag | DebugTag | RenderTag;
 
 	/** An `animate:` directive */
-	interface AnimateDirective extends BaseNode {
+	export interface AnimateDirective extends BaseNode {
 		type: 'AnimateDirective';
 		/** The 'x' in `animate:x` */
 		name: string;
@@ -1627,32 +1023,25 @@ declare module 'svelte/compiler' {
 	}
 
 	/** A `bind:` directive */
-	interface BindDirective extends BaseNode {
+	export interface BindDirective extends BaseNode {
 		type: 'BindDirective';
 		/** The 'x' in `bind:x` */
 		name: string;
 		/** The y in `bind:x={y}` */
 		expression: Identifier | MemberExpression;
-		metadata: {
-			binding_group_name: Identifier;
-			parent_each_blocks: EachBlock[];
-		};
 	}
 
 	/** A `class:` directive */
-	interface ClassDirective extends BaseNode {
+	export interface ClassDirective extends BaseNode {
 		type: 'ClassDirective';
 		/** The 'x' in `class:x` */
 		name: 'class';
 		/** The 'y' in `class:x={y}`, or the `x` in `class:x` */
 		expression: Expression;
-		metadata: {
-			expression: ExpressionMetadata;
-		};
 	}
 
 	/** A `let:` directive */
-	interface LetDirective extends BaseNode {
+	export interface LetDirective extends BaseNode {
 		type: 'LetDirective';
 		/** The 'x' in `let:x` */
 		name: string;
@@ -1661,41 +1050,28 @@ declare module 'svelte/compiler' {
 	}
 
 	/** An `on:` directive */
-	interface OnDirective extends BaseNode {
+	export interface OnDirective extends BaseNode {
 		type: 'OnDirective';
 		/** The 'x' in `on:x` */
 		name: string;
 		/** The 'y' in `on:x={y}` */
 		expression: null | Expression;
-		modifiers: string[]; // TODO specify
-		metadata: {
-			expression: ExpressionMetadata;
-		};
+		modifiers: string[];
 	}
 
-	type DelegatedEvent =
-		| {
-				hoisted: true;
-				function: ArrowFunctionExpression | FunctionExpression | FunctionDeclaration;
-		  }
-		| { hoisted: false };
-
 	/** A `style:` directive */
-	interface StyleDirective extends BaseNode {
+	export interface StyleDirective extends BaseNode {
 		type: 'StyleDirective';
 		/** The 'x' in `style:x` */
 		name: string;
 		/** The 'y' in `style:x={y}` */
 		value: true | ExpressionTag | Array<ExpressionTag | Text>;
 		modifiers: Array<'important'>;
-		metadata: {
-			expression: ExpressionMetadata;
-		};
 	}
 
 	// TODO have separate in/out/transition directives
 	/** A `transition:`, `in:` or `out:` directive */
-	interface TransitionDirective extends BaseNode {
+	export interface TransitionDirective extends BaseNode {
 		type: 'TransitionDirective';
 		/** The 'x' in `transition:x` */
 		name: string;
@@ -1709,7 +1085,7 @@ declare module 'svelte/compiler' {
 	}
 
 	/** A `use:` directive */
-	interface UseDirective extends BaseNode {
+	export interface UseDirective extends BaseNode {
 		type: 'UseDirective';
 		/** The 'x' in `use:x` */
 		name: string;
@@ -1733,81 +1109,52 @@ declare module 'svelte/compiler' {
 		fragment: Fragment;
 	}
 
-	interface Component extends BaseElement {
+	export interface Component extends BaseElement {
 		type: 'Component';
-		metadata: {
-			scopes: Record<string, Scope>;
-			dynamic: boolean;
-		};
 	}
 
-	interface TitleElement extends BaseElement {
+	export interface TitleElement extends BaseElement {
 		type: 'TitleElement';
 		name: 'title';
 	}
 
-	interface SlotElement extends BaseElement {
+	export interface SlotElement extends BaseElement {
 		type: 'SlotElement';
 		name: 'slot';
 	}
 
-	interface RegularElement extends BaseElement {
+	export interface RegularElement extends BaseElement {
 		type: 'RegularElement';
-		metadata: {
-			/** `true` if this is an svg element */
-			svg: boolean;
-			/** `true` if this is a mathml element */
-			mathml: boolean;
-			/** `true` if contains a SpreadAttribute */
-			has_spread: boolean;
-			scoped: boolean;
-		};
 	}
 
-	interface SvelteBody extends BaseElement {
+	export interface SvelteBody extends BaseElement {
 		type: 'SvelteBody';
 		name: 'svelte:body';
 	}
 
-	interface SvelteComponent extends BaseElement {
+	export interface SvelteComponent extends BaseElement {
 		type: 'SvelteComponent';
 		name: 'svelte:component';
 		expression: Expression;
-		metadata: {
-			scopes: Record<string, Scope>;
-		};
 	}
 
-	interface SvelteDocument extends BaseElement {
+	export interface SvelteDocument extends BaseElement {
 		type: 'SvelteDocument';
 		name: 'svelte:document';
 	}
 
-	interface SvelteElement extends BaseElement {
+	export interface SvelteElement extends BaseElement {
 		type: 'SvelteElement';
 		name: 'svelte:element';
 		tag: Expression;
-		metadata: {
-			/**
-			 * `true` if this is an svg element. The boolean may not be accurate because
-			 * the tag is dynamic, but we do our best to infer it from the template.
-			 */
-			svg: boolean;
-			/**
-			 * `true` if this is a mathml element. The boolean may not be accurate because
-			 * the tag is dynamic, but we do our best to infer it from the template.
-			 */
-			mathml: boolean;
-			scoped: boolean;
-		};
 	}
 
-	interface SvelteFragment extends BaseElement {
+	export interface SvelteFragment extends BaseElement {
 		type: 'SvelteFragment';
 		name: 'svelte:fragment';
 	}
 
-	interface SvelteHead extends BaseElement {
+	export interface SvelteHead extends BaseElement {
 		type: 'SvelteHead';
 		name: 'svelte:head';
 	}
@@ -1818,15 +1165,12 @@ declare module 'svelte/compiler' {
 		name: 'svelte:options';
 	}
 
-	interface SvelteSelf extends BaseElement {
+	export interface SvelteSelf extends BaseElement {
 		type: 'SvelteSelf';
 		name: 'svelte:self';
-		metadata: {
-			scopes: Record<string, Scope>;
-		};
 	}
 
-	interface SvelteWindow extends BaseElement {
+	export interface SvelteWindow extends BaseElement {
 		type: 'SvelteWindow';
 		name: 'svelte:window';
 	}
@@ -1847,7 +1191,7 @@ declare module 'svelte/compiler' {
 		| SvelteWindow;
 
 	/** An `{#each ...}` block */
-	interface EachBlock extends BaseNode {
+	export interface EachBlock extends BaseNode {
 		type: 'EachBlock';
 		expression: Expression;
 		context: Pattern;
@@ -1855,26 +1199,10 @@ declare module 'svelte/compiler' {
 		fallback?: Fragment;
 		index?: string;
 		key?: Expression;
-		metadata: {
-			expression: ExpressionMetadata;
-			keyed: boolean;
-			contains_group_binding: boolean;
-			/** Set if something in the array expression is shadowed within the each block */
-			array_name: Identifier | null;
-			index: Identifier;
-			item: Identifier;
-			declarations: Map<string, Binding>;
-			/**
-			 * Optimization path for each blocks: If the parent isn't a fragment and
-			 * it only has a single child, then we can classify the block as being "controlled".
-			 * This saves us from creating an extra comment and insertion being faster.
-			 */
-			is_controlled: boolean;
-		};
 	}
 
 	/** An `{#if ...}` block */
-	interface IfBlock extends BaseNode {
+	export interface IfBlock extends BaseNode {
 		type: 'IfBlock';
 		elseif: boolean;
 		test: Expression;
@@ -1883,7 +1211,7 @@ declare module 'svelte/compiler' {
 	}
 
 	/** An `{#await ...}` block */
-	interface AwaitBlock extends BaseNode {
+	export interface AwaitBlock extends BaseNode {
 		type: 'AwaitBlock';
 		expression: Expression;
 		// TODO can/should we move these inside the ThenBlock and CatchBlock?
@@ -1896,13 +1224,13 @@ declare module 'svelte/compiler' {
 		catch: Fragment | null;
 	}
 
-	interface KeyBlock extends BaseNode {
+	export interface KeyBlock extends BaseNode {
 		type: 'KeyBlock';
 		expression: Expression;
 		fragment: Fragment;
 	}
 
-	interface SnippetBlock extends BaseNode {
+	export interface SnippetBlock extends BaseNode {
 		type: 'SnippetBlock';
 		expression: Identifier;
 		parameters: Pattern[];
@@ -1911,44 +1239,226 @@ declare module 'svelte/compiler' {
 
 	type Block = EachBlock | IfBlock | AwaitBlock | KeyBlock | SnippetBlock;
 
-	interface Attribute extends BaseNode {
+	export interface Attribute extends BaseNode {
 		type: 'Attribute';
 		name: string;
 		value: true | ExpressionTag | Array<Text | ExpressionTag>;
-		metadata: {
-			expression: ExpressionMetadata;
-			/** May be set if this is an event attribute */
-			delegated: null | DelegatedEvent;
-		};
 	}
 
-	interface SpreadAttribute extends BaseNode {
+	export interface SpreadAttribute extends BaseNode {
 		type: 'SpreadAttribute';
 		expression: Expression;
-		metadata: {
-			expression: ExpressionMetadata;
-		};
 	}
 
-	type TemplateNode =
-		| Root
-		| Text
-		| Tag
-		| ElementLike
-		| Attribute
-		| SpreadAttribute
-		| Directive
-		| Comment
-		| Block;
-
-	type SvelteNode = Node | TemplateNode | Fragment | Css.Node;
-
-	interface Script extends BaseNode {
+	export interface Script extends BaseNode {
 		type: 'Script';
 		context: 'default' | 'module';
 		content: Program;
 		attributes: Attribute[];
 	}
+	/**
+	 * The preprocess function provides convenient hooks for arbitrarily transforming component source code.
+	 * For example, it can be used to convert a <style lang="sass"> block into vanilla CSS.
+	 *
+	 * https://svelte.dev/docs/svelte-compiler#svelte-preprocess
+	 * */
+	export function preprocess(source: string, preprocessor: PreprocessorGroup | PreprocessorGroup[], options?: {
+		filename?: string;
+	} | undefined): Promise<Processed>;
+	/**
+	 * The current version, as set in package.json.
+	 *
+	 * https://svelte.dev/docs/svelte-compiler#svelte-version
+	 * */
+	export const VERSION: string;
+	/**
+	 * Does a best-effort migration of Svelte code towards using runes, event attributes and render tags.
+	 * May throw an error if the code is too complex to migrate automatically.
+	 *
+	 * */
+	export function migrate(source: string): {
+		code: string;
+	};
+	namespace Css {
+		export interface BaseNode {
+			start: number;
+			end: number;
+		}
+
+		export interface StyleSheet extends BaseNode {
+			type: 'StyleSheet';
+			attributes: any[]; // TODO
+			children: Array<Atrule | Rule>;
+			content: {
+				start: number;
+				end: number;
+				styles: string;
+				/** Possible comment atop the style tag */
+				comment: Comment | null;
+			};
+		}
+
+		export interface Atrule extends BaseNode {
+			type: 'Atrule';
+			name: string;
+			prelude: string;
+			block: Block | null;
+		}
+
+		export interface Rule extends BaseNode {
+			type: 'Rule';
+			prelude: SelectorList;
+			block: Block;
+			metadata: {
+				parent_rule: null | Rule;
+				has_local_selectors: boolean;
+				/**
+				 * `true` if the rule contains a `:global` selector, and therefore everything inside should be unscoped
+				 */
+				is_global_block: boolean;
+			};
+		}
+
+		/**
+		 * A list of selectors, e.g. `a, b, c {}`
+		 */
+		export interface SelectorList extends BaseNode {
+			type: 'SelectorList';
+			/**
+			 * The `a`, `b` and `c` in `a, b, c {}`
+			 */
+			children: ComplexSelector[];
+		}
+
+		/**
+		 * A complex selector, e.g. `a b c {}`
+		 */
+		export interface ComplexSelector extends BaseNode {
+			type: 'ComplexSelector';
+			/**
+			 * The `a`, `b` and `c` in `a b c {}`
+			 */
+			children: RelativeSelector[];
+			metadata: {
+				rule: null | Rule;
+				used: boolean;
+			};
+		}
+
+		/**
+		 * A relative selector, e.g the `a` and `> b` in `a > b {}`
+		 */
+		export interface RelativeSelector extends BaseNode {
+			type: 'RelativeSelector';
+			/**
+			 * In `a > b`, `> b` forms one relative selector, and `>` is the combinator. `null` for the first selector.
+			 */
+			combinator: null | Combinator;
+			/**
+			 * The `b:is(...)` in `> b:is(...)`
+			 */
+			selectors: SimpleSelector[];
+			metadata: {
+				/**
+				 * `true` if the whole selector is unscoped, e.g. `:global(...)` or `:global` or `:global.x`.
+				 * Selectors like `:global(...).x` are not considered global, because they still need scoping.
+				 */
+				is_global: boolean;
+				/** `:root`, `:host`, `::view-transition`, or selectors after a `:global` */
+				is_global_like: boolean;
+				scoped: boolean;
+			};
+		}
+
+		export interface TypeSelector extends BaseNode {
+			type: 'TypeSelector';
+			name: string;
+		}
+
+		export interface IdSelector extends BaseNode {
+			type: 'IdSelector';
+			name: string;
+		}
+
+		export interface ClassSelector extends BaseNode {
+			type: 'ClassSelector';
+			name: string;
+		}
+
+		export interface AttributeSelector extends BaseNode {
+			type: 'AttributeSelector';
+			name: string;
+			matcher: string | null;
+			value: string | null;
+			flags: string | null;
+		}
+
+		export interface PseudoElementSelector extends BaseNode {
+			type: 'PseudoElementSelector';
+			name: string;
+		}
+
+		export interface PseudoClassSelector extends BaseNode {
+			type: 'PseudoClassSelector';
+			name: string;
+			args: SelectorList | null;
+		}
+
+		export interface Percentage extends BaseNode {
+			type: 'Percentage';
+			value: string;
+		}
+
+		export interface NestingSelector extends BaseNode {
+			type: 'NestingSelector';
+			name: '&';
+		}
+
+		export interface Nth extends BaseNode {
+			type: 'Nth';
+			value: string;
+		}
+
+		export type SimpleSelector =
+			| TypeSelector
+			| IdSelector
+			| ClassSelector
+			| AttributeSelector
+			| PseudoElementSelector
+			| PseudoClassSelector
+			| Percentage
+			| Nth
+			| NestingSelector;
+
+		export interface Combinator extends BaseNode {
+			type: 'Combinator';
+			name: string;
+		}
+
+		export interface Block extends BaseNode {
+			type: 'Block';
+			children: Array<Declaration | Rule | Atrule>;
+		}
+
+		export interface Declaration extends BaseNode {
+			type: 'Declaration';
+			property: string;
+			value: string;
+		}
+
+		// for zimmerframe
+		export type Node =
+			| StyleSheet
+			| Rule
+			| Atrule
+			| SelectorList
+			| Block
+			| ComplexSelector
+			| RelativeSelector
+			| Combinator
+			| SimpleSelector
+			| Declaration;
+	}
 	type ICompileDiagnostic = {
 		code: string;
 		message: string;