diff --git a/.changeset/social-boxes-add.md b/.changeset/social-boxes-add.md
new file mode 100644
index 000000000..b9acfd41e
--- /dev/null
+++ b/.changeset/social-boxes-add.md
@@ -0,0 +1,5 @@
+---
+'@sveltejs/sv-utils': patch
+---
+
+feat: add `transform` api to simplify add-on creation
diff --git a/documentation/docs/40-api/10-add-on.md b/documentation/docs/40-api/10-add-on.md
index 9403a6156..d37b245e0 100644
--- a/documentation/docs/40-api/10-add-on.md
+++ b/documentation/docs/40-api/10-add-on.md
@@ -13,7 +13,6 @@ The easiest way to create an add-on is using the addon template:
 
 ```sh
 npx sv create --template addon my-addon
-cd my-addon
 ```
 
 ## Add-on structure
@@ -23,7 +22,8 @@ Typically, an add-on looks like this:
 _hover keywords in the code to have some more context_
 
 ```js
-import { parse, svelte } from '@sveltejs/sv-utils';
+// @noErrors
+import { transforms } from '@sveltejs/sv-utils';
 import { defineAddon, defineAddonOptions } from 'sv';
 
 // Define options that will be prompted to the user (or passed as arguments)
@@ -37,6 +37,8 @@ const options = defineAddonOptions()
 // your add-on definition, the entry point
 export default defineAddon({
 	id: 'your-addon-name',
+	// shortDescription: 'does X',   // optional: one-liner shown in prompts
+	// homepage: 'https://...',      // optional: link to docs/repo
 
 	options,
 
@@ -46,21 +48,20 @@ export default defineAddon({
 	},
 
 	// actual execution of the addon
-	run: ({ kit, cancel, sv, options }) => {
-		if (!kit) return cancel('SvelteKit is required');
+	run: ({ isKit, cancel, sv, options, directory }) => {
+		if (!isKit) return cancel('SvelteKit is required');
 
 		// Add "Hello [who]!" to the root page
-		sv.file(kit.routesDirectory + '/+page.svelte', (content) => {
-			const { ast, generateCode } = parse.svelte(content);
-
+		sv.file(directory.routes + '/+page.svelte', transforms.svelte(({ ast, svelte }) => {
 			svelte.addFragment(ast, `<p>Hello ${options.who}!</p>`);
-
-			return generateCode();
-		});
+		}));
 	}
 });
 ```
 
+> `sv` owns the file system - `sv.file()` resolves the path, reads the file, applies the edit function, and writes the result.
+> `@sveltejs/sv-utils` owns the content - `transforms.svelte()` returns a curried function that handles parsing, gives you the AST and utils, and serializes back. See [sv-utils](/docs/cli/sv-utils) for the full API.
+
 ## Development with `file:` protocol
 
 While developing your add-on, you can test it locally using the `file:` protocol:
@@ -77,8 +78,8 @@ This allows you to iterate quickly without publishing to npm.
 The `sv/testing` module provides utilities for testing your add-on:
 
 ```js
-import { test, expect } from 'vitest';
 import { setupTest } from 'sv/testing';
+import { test, expect } from 'vitest';
 import addon from './index.js';
 
 test('adds hello message', async () => {
@@ -94,11 +95,19 @@ test('adds hello message', async () => {
 });
 ```
 
-## Publishing to npm
+## Building and publishing
+
+### Bundling
+
+Community add-ons are bundled with [tsdown](https://tsdown.dev/) into a single file. Everything is bundled except `sv` (peer dependency, provided at runtime).
+
+```sh
+npm run build
+```
 
 ### Package structure
 
-Your add-on must have `sv` as a dependency in `package.json`:
+Your add-on must have `sv` as a peer dependency and **no** `dependencies` in `package.json`:
 
 ```json
 {
@@ -106,15 +115,24 @@ Your add-on must have `sv` as a dependency in `package.json`:
 	"version": "1.0.0",
 	"type": "module",
 	"exports": {
-		".": "./dist/index.js"
+		".": "./src/index.js"
+	},
+	"publishConfig": {
+		"access": "public",
+		"exports": {
+			".": { "default": "./dist/index.js" }
+		}
 	},
-	"dependencies": {
-		"sv": "^0.11.0"
+	"peerDependencies": {
+		"sv": "^0.13.0"
 	},
 	"keywords": ["sv-add"]
 }
 ```
 
+- `exports` points to `./src/index.js` for local development with the `file:` protocol.
+- `publishConfig.exports` overrides exports when publishing, pointing to the bundled `./dist/index.js`.
+
 > [!NOTE]
 > Add the `sv-add` keyword so users can discover your add-on on npm.
 
@@ -127,7 +145,7 @@ Your package can export the add-on in two ways:
    ```json
    {
    	"exports": {
-   		".": "./dist/index.js"
+   		".": "./src/index.js"
    	}
    }
    ```
@@ -136,17 +154,38 @@ Your package can export the add-on in two ways:
    ```json
    {
    	"exports": {
-   		".": "./dist/main.js",
-   		"./sv": "./dist/addon.js"
+   		".": "./src/main.js",
+   		"./sv": "./src/addon.js"
    	}
    }
    ```
 
-### Naming conventions
+### Publishing
+
+Community add-ons must be scoped packages (e.g. `@your-org/sv`). Users install with `npx sv add @your-org`.
+
+```sh
+npm login
+npm publish
+```
+
+> `prepublishOnly` automatically runs the build before publishing.
 
-- **Scoped packages**: Use `@your-org/sv` as the package name. Users can then install with just `npx sv add @your-org`.
-- **Regular packages**: Any name works. Users install with `npx sv add your-package-name`.
+## Next steps
+
+You can optionally display guidance after your add-on runs:
+
+```js
+// @noErrors
+export default defineAddon({
+	// ...
+	nextSteps: ({ options }) => [
+		`Run ${color.command('npm run dev')} to start developing`,
+		`Check out the docs at https://...`
+	]
+});
+```
 
 ## Version compatibility
 
-Your add-on should specify the minimum `sv` version it requires in `package.json`. If a user's `sv` version has a different major version than what your add-on was built for, they will see a compatibility warning.
+Your add-on should specify the minimum `sv` version it requires in `peerDependencies`. If a user's `sv` version has a different major version than what your add-on was built for, they will see a compatibility warning.
diff --git a/documentation/docs/40-api/20-sv-utils.md b/documentation/docs/40-api/20-sv-utils.md
index 90f411b1e..25c9ea98b 100644
--- a/documentation/docs/40-api/20-sv-utils.md
+++ b/documentation/docs/40-api/20-sv-utils.md
@@ -8,5 +8,195 @@ title: sv-utils
 `@sveltejs/sv-utils` provides utilities for parsing, transforming, and generating code in add-ons.
 
 ```sh
-npm install @sveltejs/sv-utils
+npm install -D @sveltejs/sv-utils
 ```
+
+## Architecture
+
+The Svelte CLI is split into two packages with a clear boundary:
+
+- **`sv`** = **where and when** to do it. It owns paths, workspace detection, dependency tracking, and file I/O. The engine orchestrates add-on execution.
+- **`@sveltejs/sv-utils`** = **what** to do to content. It provides parsers, language tooling, and typed transforms. Everything here is pure - no file system, no workspace awareness.
+
+This separation means transforms are testable without a workspace and composable across add-ons.
+
+## Transforms
+
+Transforms are curried, parser-aware functions that turn `string -> string`. Call a transform with your callback to get a function that plugs directly into `sv.file()`. The parser choice is baked into the transform type - you can't accidentally parse a vite config as Svelte because you never call a parser yourself.
+
+Each transform injects relevant utilities into the callback, so you only need one import:
+
+```js
+import { transforms } from '@sveltejs/sv-utils';
+```
+
+### `transforms.script`
+
+Transform a JavaScript/TypeScript file. The callback receives `{ ast, comments, content, js }`.
+
+```js
+// @noErrors
+import { transforms } from '@sveltejs/sv-utils';
+
+sv.file(files.viteConfig, transforms.script(({ ast, js }) => {
+	js.imports.addDefault(ast, { as: 'foo', from: 'foo' });
+	js.vite.addPlugin(ast, { code: 'foo()' });
+}));
+```
+
+### `transforms.svelte`
+
+Transform a Svelte component. The callback receives `{ ast, content, svelte, js }`.
+
+```js
+// @noErrors
+import { transforms } from '@sveltejs/sv-utils';
+
+sv.file(layoutPath, transforms.svelte(({ ast, svelte }) => {
+	svelte.addFragment(ast, '<Foo />');
+}));
+```
+
+### `transforms.svelteScript`
+
+Transform a Svelte component with a `<script>` block guaranteed. Pass `{ language }` as the first argument. The callback receives `{ ast, content, svelte, js }` where `ast.instance` is always non-null.
+
+```js
+// @noErrors
+import { transforms } from '@sveltejs/sv-utils';
+
+sv.file(layoutPath, transforms.svelteScript({ language }, ({ ast, svelte, js }) => {
+	js.imports.addDefault(ast.instance.content, { as: 'Foo', from: './Foo.svelte' });
+	svelte.addFragment(ast, '<Foo />');
+}));
+```
+
+### `transforms.css`
+
+Transform a CSS file. The callback receives `{ ast, content, css }`.
+
+```js
+// @noErrors
+import { transforms } from '@sveltejs/sv-utils';
+
+sv.file(files.stylesheet, transforms.css(({ ast, css }) => {
+	css.addAtRule(ast, { name: 'import', params: "'tailwindcss'" });
+}));
+```
+
+### `transforms.json`
+
+Transform a JSON file. Mutate the `data` object directly. The callback receives `{ data, content, json }`.
+
+```js
+// @noErrors
+import { transforms } from '@sveltejs/sv-utils';
+
+sv.file(files.tsconfig, transforms.json(({ data }) => {
+	data.compilerOptions ??= {};
+	data.compilerOptions.strict = true;
+}));
+```
+
+### `transforms.yaml` / `transforms.toml`
+
+Same pattern as `transforms.json`, for YAML and TOML files respectively. The callback receives `{ data, content }`.
+
+### `transforms.text`
+
+Transform a plain text file (.env, .gitignore, etc.). No parser - string in, string out. The callback receives `{ content, text }`.
+
+```js
+// @noErrors
+import { transforms } from '@sveltejs/sv-utils';
+
+sv.file('.env', transforms.text(({ content }) => {
+	return content + '\nDATABASE_URL="file:local.db"';
+}));
+```
+
+### Aborting a transform
+
+Return `false` from any transform callback to abort - the original content is returned unchanged.
+
+```js
+// @noErrors
+import { transforms } from '@sveltejs/sv-utils';
+
+sv.file(files.eslintConfig, transforms.script(({ ast, js }) => {
+	const { value: existing } = js.exports.createDefault(ast, { fallback: myConfig });
+	if (existing !== myConfig) {
+		// config already exists, don't touch it
+		return false;
+	}
+	// ... continue modifying ast
+}));
+```
+
+### Standalone usage & testing
+
+Transforms are curried functions - call them with the callback, then apply to content:
+
+```js
+import { transforms } from '@sveltejs/sv-utils';
+
+const result = transforms.script(({ ast, js }) => {
+	js.imports.addDefault(ast, { as: 'foo', from: 'foo' });
+})('export default {}');
+```
+
+### Composability
+
+For cases where you need to mix transforms and raw edits, use `sv.file` with a content callback and invoke the curried transform manually:
+
+```js
+// @noErrors
+sv.file(path, (content) => {
+	content = transforms.script(({ ast, js }) => {
+		js.imports.addDefault(ast, { as: 'foo', from: 'foo' });
+	})(content);
+	content = content.replace('foo', 'bar');
+	return content;
+});
+```
+
+Add-ons can also export reusable transform functions:
+
+```js
+// @errors: 7006
+import { transforms } from '@sveltejs/sv-utils';
+
+// reusable - export from your package
+export const addFooImport = transforms.svelte(({ ast, svelte, js }) => {
+	svelte.ensureScript(ast, { language });
+	js.imports.addDefault(ast.instance.content, { as: 'Foo', from: './Foo.svelte' });
+});
+```
+
+## Parsers (low-level)
+
+For cases where transforms don't fit (e.g., conditional parsing, error handling around the parser), the `parse` namespace is still available:
+
+```js
+// @noErrors
+import { parse } from '@sveltejs/sv-utils';
+
+const { ast, generateCode } = parse.script(content);
+const { ast, generateCode } = parse.svelte(content);
+const { ast, generateCode } = parse.css(content);
+const { data, generateCode } = parse.json(content);
+const { data, generateCode } = parse.yaml(content);
+const { data, generateCode } = parse.toml(content);
+const { ast, generateCode } = parse.html(content);
+```
+
+## Language tooling
+
+Namespaced helpers for AST manipulation:
+
+- **`js.*`** - imports, exports, objects, arrays, variables, functions, vite config helpers, SvelteKit helpers
+- **`css.*`** - rules, declarations, at-rules, imports
+- **`svelte.*`** - ensureScript, addSlot, addFragment
+- **`json.*`** - arrayUpsert, packageScriptsUpsert
+- **`html.*`** - attribute manipulation
+- **`text.*`** - upsert lines in flat files (.env, .gitignore)
diff --git a/packages/sv-utils/src/index.ts b/packages/sv-utils/src/index.ts
index 84f8c0256..ad6df04f4 100644
--- a/packages/sv-utils/src/index.ts
+++ b/packages/sv-utils/src/index.ts
@@ -28,21 +28,26 @@ export * as text from './tooling/text.ts';
 export * as json from './tooling/json.ts';
 export * as svelte from './tooling/svelte/index.ts';
 
+// Transforms — sv-utils = what to do to content, sv = where and when to do it.
+export { transforms } from './tooling/transforms.ts';
+
 /**
- * Will help you `parse` code into an `ast` from all supported languages.
- * Then manipulate the `ast` as you want,
- * and finally `generateCode()` to write it back to the file.
+ * Low-level parsers. Prefer `transforms` for add-on file edits — it picks the
+ * right parser for you and handles `generateCode()` automatically.
+ *
+ * Use `parse` directly when you need error handling around parsing or
+ * conditional parser selection at runtime.
  *
  * ```ts
  * import { parse } from '@sveltejs/sv-utils';
  *
- * const { ast, generateCode } = parse.css('body { color: red; }');
- * const { ast, generateCode } = parse.html('<div>Hello, world!</div>');
- * const { ast, generateCode } = parse.json('{ "name": "John", "age": 30 }');
  * const { ast, generateCode } = parse.script('function add(a, b) { return a + b; }');
  * const { ast, generateCode } = parse.svelte('<div>Hello, world!</div>');
- * const { ast, generateCode } = parse.toml('name = "John"');
- * const { ast, generateCode } = parse.yaml('name: John');
+ * const { ast, generateCode } = parse.css('body { color: red; }');
+ * const { data, generateCode } = parse.json('{ "name": "John", "age": 30 }');
+ * const { data, generateCode } = parse.yaml('name: John');
+ * const { data, generateCode } = parse.toml('name = "John"');
+ * const { ast, generateCode } = parse.html('<div>Hello, world!</div>');
  * ```
  */
 export const parse = {
@@ -77,3 +82,4 @@ export { color } from './color.ts';
 
 // Types
 export type { Comments, AstTypes, SvelteAst } from './tooling/index.ts';
+export type { TransformFn } from './tooling/transforms.ts';
diff --git a/packages/sv-utils/src/tests/transforms.ts b/packages/sv-utils/src/tests/transforms.ts
new file mode 100644
index 000000000..cbe06212f
--- /dev/null
+++ b/packages/sv-utils/src/tests/transforms.ts
@@ -0,0 +1,168 @@
+import { describe, expect, it } from 'vitest';
+import { transforms } from '../tooling/transforms.ts';
+
+describe('transforms', () => {
+	describe('json', () => {
+		it('roundtrip: parse -> mutate -> generateCode', () => {
+			const input = '{"name":"old"}';
+			const result = transforms.json(({ data }) => {
+				data.name = 'new';
+			})(input);
+			expect(JSON.parse(result)).toEqual({ name: 'new' });
+		});
+
+		it('abort: returns original content on false', () => {
+			const input = '{"name":"old"}';
+			expect(transforms.json(() => false)(input)).toBe(input);
+		});
+
+		it('onError: calls handler and returns original content', () => {
+			const input = 'not: json';
+			let caught = false;
+			const result = transforms.json(() => {}, {
+				onError: () => {
+					caught = true;
+				}
+			})(input);
+			expect(result).toBe(input);
+			expect(caught).toBe(true);
+		});
+
+		it('throws on parse error without onError', () => {
+			expect(() => transforms.json(() => {})('not: json')).toThrow();
+		});
+	});
+
+	describe('text', () => {
+		it('transforms content', () => {
+			expect(transforms.text(({ content }) => content + '\nappended')('line1')).toBe(
+				'line1\nappended'
+			);
+		});
+
+		it('abort: returns original content on false', () => {
+			const input = 'original';
+			expect(transforms.text(() => false)(input)).toBe(input);
+		});
+	});
+
+	describe('script', () => {
+		it('roundtrip: parse -> mutate -> generateCode', () => {
+			const input = 'const x = 1;';
+			const result = transforms.script(({ ast }) => {
+				const decl = ast.body[0];
+				if (decl.type === 'VariableDeclaration') {
+					const declarator = decl.declarations[0];
+					if (declarator.id.type === 'Identifier') {
+						declarator.id.name = 'y';
+					}
+				}
+			})(input);
+			expect(result).toContain('const y = 1');
+		});
+
+		it('abort: returns original content on false', () => {
+			const input = 'const x = 1;';
+			expect(transforms.script(() => false)(input)).toBe(input);
+		});
+
+		it('onError: calls handler and returns original content', () => {
+			let caught = false;
+			const result = transforms.script(() => {}, {
+				onError: () => {
+					caught = true;
+				}
+			})('this is not valid {{{ js');
+			expect(result).toBe('this is not valid {{{ js');
+			expect(caught).toBe(true);
+		});
+	});
+
+	describe('svelte', () => {
+		it('roundtrip: parse -> mutate -> generateCode', () => {
+			const input = '<p>hello</p>';
+			const result = transforms.svelte(({ ast }) => {
+				const node = ast.fragment.nodes[0];
+				if (node.type === 'RegularElement') {
+					const textNode = node.fragment.nodes[0];
+					if (textNode.type === 'Text') {
+						textNode.data = 'world';
+					}
+				}
+			})(input);
+			expect(result).toContain('world');
+		});
+
+		it('abort: returns original content on false', () => {
+			const input = '<p>hello</p>';
+			expect(transforms.svelte(() => false)(input)).toBe(input);
+		});
+	});
+
+	describe('css', () => {
+		it('roundtrip: parse -> mutate -> generateCode', () => {
+			const input = 'body { color: red; }';
+			const result = transforms.css(({ ast, css }) => {
+				css.addAtRule(ast, { name: 'import', params: "'tailwindcss'", append: false });
+			})(input);
+			expect(result).toContain("@import 'tailwindcss'");
+			expect(result).toContain('body');
+		});
+
+		it('abort: returns original content on false', () => {
+			const input = 'body { color: red; }';
+			expect(transforms.css(() => false)(input)).toBe(input);
+		});
+	});
+
+	describe('html', () => {
+		it('roundtrip: parse -> mutate -> generateCode', () => {
+			const input = '<div>hello</div>';
+			const result = transforms.html(({ ast }) => {
+				const node = ast.nodes[0];
+				if (node.type === 'RegularElement') {
+					const textNode = node.fragment.nodes[0];
+					if (textNode.type === 'Text') {
+						textNode.data = 'world';
+					}
+				}
+			})(input);
+			expect(result).toContain('world');
+		});
+
+		it('abort: returns original content on false', () => {
+			const input = '<div>hello</div>';
+			expect(transforms.html(() => false)(input)).toBe(input);
+		});
+	});
+
+	describe('yaml', () => {
+		it('roundtrip: parse -> mutate -> generateCode', () => {
+			const input = 'name: old\n';
+			const result = transforms.yaml(({ data }) => {
+				data.set('name', 'new');
+			})(input);
+			expect(result).toContain('name: new');
+		});
+
+		it('abort: returns original content on false', () => {
+			const input = 'name: old\n';
+			expect(transforms.yaml(() => false)(input)).toBe(input);
+		});
+	});
+
+	describe('toml', () => {
+		it('roundtrip: parse -> mutate -> generateCode', () => {
+			const input = 'name = "old"\n';
+			const result = transforms.toml(({ data }) => {
+				data.name = 'new';
+			})(input);
+			expect(result).toContain('name = "new"');
+		});
+
+		it('abort: returns original content on false', () => {
+			const input = 'name = "old"\n';
+			expect(transforms.toml(() => false)(input)).toBe(input);
+		});
+	});
+});
diff --git a/packages/sv-utils/src/tooling/svelte/index.ts b/packages/sv-utils/src/tooling/svelte/index.ts
index 35dcf2cf4..02bbbaf7e 100644
--- a/packages/sv-utils/src/tooling/svelte/index.ts
+++ b/packages/sv-utils/src/tooling/svelte/index.ts
@@ -2,7 +2,7 @@ import { parseScript, type SvelteAst } from '../index.ts';
 import { appendFromString } from '../js/common.ts';
 import { parseSvelte } from '../parsers.ts';
 
-type RootWithInstance = SvelteAst.Root & { instance: SvelteAst.Script };
+export type RootWithInstance = SvelteAst.Root & { instance: SvelteAst.Script };
 
 // because we create instance if it doesn't exist, we can assert its presence
 // for all further processing after calling this function.
diff --git a/packages/sv-utils/src/tooling/transforms.ts b/packages/sv-utils/src/tooling/transforms.ts
new file mode 100644
index 000000000..5d27c1696
--- /dev/null
+++ b/packages/sv-utils/src/tooling/transforms.ts
@@ -0,0 +1,254 @@
+import type { TomlTable } from 'smol-toml';
+import * as cssNs from './css/index.ts';
+import * as htmlNs from './html/index.ts';
+import type { Comments, SvelteAst } from './index.ts';
+import * as jsNs from './js/index.ts';
+import type { TsEstree } from './js/ts-estree.ts';
+import * as jsonNs from './json.ts';
+import {
+	parseCss,
+	parseHtml,
+	parseJson,
+	parseScript,
+	parseSvelte,
+	parseToml,
+	parseYaml
+} from './parsers.ts';
+import { type RootWithInstance, ensureScript } from './svelte/index.ts';
+import * as svelteNs from './svelte/index.ts';
+import * as textNs from './text.ts';
+
+export type TransformFn = (content: string) => string;
+
+type TransformOptions = {
+	/** Called when parsing fails. If provided, the original content is returned unchanged. */
+	onError?: (error: unknown) => void;
+};
+
+function withParseError<T>(parseFn: () => T, options?: TransformOptions): T | undefined {
+	try {
+		return parseFn();
+	} catch (error) {
+		if (options?.onError) {
+			options.onError(error);
+			return undefined;
+		}
+		throw error;
+	}
+}
+
+/**
+ * File transform primitives that know their format.
+ *
+ * `sv-utils = what to do to content, sv = where and when to do it.`
+ *
+ * Each transform wraps: parse -> callback({ast/data, utils}) -> generateCode().
+ * The parser choice is baked into the transform type - you can't accidentally
+ * parse a vite config as svelte because you never call a parser yourself.
+ *
+ * Transforms are curried: call with the callback to get a `(content: string) => string`
+ * function that plugs directly into `sv.file()`.
+ *
+ * @example
+ * ```ts
+ * import { transforms } from '@sveltejs/sv-utils';
+ *
+ * // use with sv.file() - curried form plugs in directly
+ * sv.file(files.viteConfig, transforms.script(({ ast, js }) => {
+ *   js.vite.addPlugin(ast, { code: 'kitRoutes()' });
+ * }));
+ *
+ * // standalone usage / testing
+ * const result = transforms.script(({ ast, js }) => {
+ *   js.imports.addDefault(ast, { as: 'foo', from: 'foo' });
+ * })(fileContent);
+ * ```
+ */
+export const transforms = {
+	/**
+	 * Transform a JavaScript/TypeScript file.
+	 *
+	 * Return `false` from the callback to abort - the original content is returned unchanged.
+	 */
+	script(
+		cb: (file: {
+			ast: TsEstree.Program;
+			comments: Comments;
+			content: string;
+			js: typeof jsNs;
+		}) => void | false,
+		options?: TransformOptions
+	): (content: string) => string {
+		return (content) => {
+			const parsed = withParseError(() => parseScript(content), options);
+			if (!parsed) return content;
+			const result = cb({ ast: parsed.ast, comments: parsed.comments, content, js: jsNs });
+			if (result === false) return content;
+			return parsed.generateCode();
+		};
+	},
+
+	/**
+	 * Transform a Svelte component file.
+	 *
+	 * Return `false` from the callback to abort - the original content is returned unchanged.
+	 */
+	svelte(
+		cb: (file: {
+			ast: SvelteAst.Root;
+			content: string;
+			svelte: typeof svelteNs;
+			js: typeof jsNs;
+		}) => void | false,
+		options?: TransformOptions
+	): (content: string) => string {
+		return (content) => {
+			const parsed = withParseError(() => parseSvelte(content), options);
+			if (!parsed) return content;
+			const result = cb({ ast: parsed.ast, content, svelte: svelteNs, js: jsNs });
+			if (result === false) return content;
+			return parsed.generateCode();
+		};
+	},
+
+	/**
+	 * Transform a Svelte component file with a script block guaranteed.
+	 *
+	 * Calls `ensureScript` before invoking your callback, so `ast.instance` is always non-null.
+	 * Pass `{ language }` as the first argument to set the script language.
+	 *
+	 * Return `false` from the callback to abort - the original content is returned unchanged.
+	 */
+	svelteScript(
+		scriptOptions: { language: 'ts' | 'js' },
+		cb: (file: {
+			ast: RootWithInstance;
+			content: string;
+			svelte: typeof svelteNs;
+			js: typeof jsNs;
+		}) => void | false,
+		options?: TransformOptions
+	): TransformFn {
+		return (content) => {
+			const parsed = withParseError(() => parseSvelte(content), options);
+			if (!parsed) return content;
+			ensureScript(parsed.ast, scriptOptions);
+			const result = cb({
+				ast: parsed.ast as RootWithInstance,
+				content,
+				svelte: svelteNs,
+				js: jsNs
+			});
+			if (result === false) return content;
+			return parsed.generateCode();
+		};
+	},
+
+	/**
+	 * Transform a CSS file.
+	 *
+	 * Return `false` from the callback to abort - the original content is returned unchanged.
+	 */
+	css(
+		cb: (file: {
+			ast: Omit<SvelteAst.CSS.StyleSheetBase, 'attributes' | 'content'>;
+			content: string;
+			css: typeof cssNs;
+		}) => void | false,
+		options?: TransformOptions
+	): TransformFn {
+		return (content) => {
+			const parsed = withParseError(() => parseCss(content), options);
+			if (!parsed) return content;
+			const result = cb({ ast: parsed.ast, content, css: cssNs });
+			if (result === false) return content;
+			return parsed.generateCode();
+		};
+	},
+
+	/**
+	 * Transform a JSON file.
+	 *
+	 * Return `false` from the callback to abort - the original content is returned unchanged.
+	 */
+	json<T = any>(
+		cb: (file: { data: T; content: string; json: typeof jsonNs }) => void | false,
+		options?: TransformOptions
+	): TransformFn {
+		return (content) => {
+			const parsed = withParseError(() => parseJson(content), options);
+			if (!parsed) return content;
+			const result = cb({ data: parsed.data as T, content, json: jsonNs });
+			if (result === false) return content;
+			return parsed.generateCode();
+		};
+	},
+
+	/**
+	 * Transform a YAML file.
+	 *
+	 * Return `false` from the callback to abort - the original content is returned unchanged.
+	 */
+	yaml(
+		cb: (file: { data: ReturnType<typeof parseYaml>['data']; content: string }) => void | false,
+		options?: TransformOptions
+	): TransformFn {
+		return (content) => {
+			const parsed = withParseError(() => parseYaml(content), options);
+			if (!parsed) return content;
+			const result = cb({ data: parsed.data, content });
+			if (result === false) return content;
+			return parsed.generateCode();
+		};
+	},
+
+	/**
+	 * Transform a TOML file.
+	 *
+	 * Return `false` from the callback to abort - the original content is returned unchanged.
+	 */
+	toml(
+		cb: (file: { data: TomlTable; content: string }) => void | false,
+		options?: TransformOptions
+	): TransformFn {
+		return (content) => {
+			const parsed = withParseError(() => parseToml(content), options);
+			if (!parsed) return content;
+			const result = cb({ data: parsed.data, content });
+			if (result === false) return content;
+			return parsed.generateCode();
+		};
+	},
+
+	/**
+	 * Transform an HTML file (e.g. app.html).
+	 *
+	 * Return `false` from the callback to abort - the original content is returned unchanged.
+	 */
+	html(
+		cb: (file: { ast: SvelteAst.Fragment; content: string; html: typeof htmlNs }) => void | false,
+		options?: TransformOptions
+	): TransformFn {
+		return (content) => {
+			const parsed = withParseError(() => parseHtml(content), options);
+			if (!parsed) return content;
+			const result = cb({ ast: parsed.ast, content, html: htmlNs });
+			if (result === false) return content;
+			return parsed.generateCode();
+		};
+	},
+
+	/**
+	 * Transform a plain text file (.env, .gitignore, etc.).
+	 *
+	 * Unlike other transforms there's no AST here - just string in, string out.
+	 * Return the new content, or `false` to abort (original content is returned unchanged).
+	 */
+	text(cb: (file: { content: string; text: typeof textNs }) => string | false): TransformFn {
+		return (content) => {
+			const result = cb({ content, text: textNs });
+			if (result === false) return content;
+			return result;
+		};
+	}
+};
diff --git a/packages/sv/src/addons/better-auth.ts b/packages/sv/src/addons/better-auth.ts
index 87a263333..838a407d3 100644
--- a/packages/sv/src/addons/better-auth.ts
+++ b/packages/sv/src/addons/better-auth.ts
@@ -4,12 +4,10 @@ import {
 	Walker,
 	color,
 	dedent,
-	text,
-	js,
-	json,
-	parse,
+	transforms,
 	resolveCommand,
-	createPrinter
+	createPrinter,
+	type TransformFn
 } from '@sveltejs/sv-utils';
 import crypto from 'node:crypto';
 import { defineAddon, defineAddonOptions } from '../core/config.ts';
@@ -53,74 +51,81 @@ export default defineAddon({
 		sv.devDependency('better-auth', '~1.4.21');
 		sv.devDependency('@better-auth/cli', '~1.4.21');
 
-		sv.file(`drizzle.config.${language}`, (content) => {
-			const { ast, generateCode } = parse.script(content);
-			const isProp = (name: string, node: AstTypes.Property) =>
-				node.key.type === 'Identifier' && node.key.name === name;
-
-			// tsgo can't infer visitor node types from zimmerframe's distributive conditional
-			Walker.walk(ast as AstTypes.Node, null, {
-				Property(node: AstTypes.Property) {
-					if (
-						isProp('dialect', node) &&
-						node.value.type === 'Literal' &&
-						typeof node.value.value === 'string'
-					) {
-						drizzleDialect = node.value.value as Dialect;
-					}
-					if (
-						isProp('driver', node) &&
-						node.value.type === 'Literal' &&
-						node.value.value === 'd1-http'
-					) {
-						d1 = true;
+		// Read-only: extract dialect info from drizzle config without modifying it
+		sv.file(
+			`drizzle.config.${language}`,
+			transforms.script(({ ast }) => {
+				const isProp = (name: string, node: AstTypes.Property) =>
+					node.key.type === 'Identifier' && node.key.name === name;
+
+				// tsgo can't infer visitor node types from zimmerframe's distributive conditional
+				Walker.walk(ast as AstTypes.Node, null, {
+					Property(node: AstTypes.Property) {
+						if (
+							isProp('dialect', node) &&
+							node.value.type === 'Literal' &&
+							typeof node.value.value === 'string'
+						) {
+							drizzleDialect = node.value.value as Dialect;
+						}
+						if (
+							isProp('driver', node) &&
+							node.value.type === 'Literal' &&
+							node.value.value === 'd1-http'
+						) {
+							d1 = true;
+						}
 					}
-				}
-			});
-
-			if (!drizzleDialect) {
-				throw new Error('Failed to detect DB dialect in your `drizzle.config.[js|ts]` file');
-			}
-			return generateCode();
-		});
+				});
 
-		sv.file('.env', (content) => generateEnvFileContent(content, demoGithub, false));
-		sv.file('.env.example', (content) => generateEnvFileContent(content, demoGithub, true));
+				if (!drizzleDialect) {
+					throw new Error('Failed to detect DB dialect in your `drizzle.config.[js|ts]` file');
+				}
 
-		sv.file(`${directory.lib}/server/auth.${language}`, (content) => {
-			const { ast, generateCode, comments } = parse.script(content);
+				return false;
+			})
+		);
+
+		sv.file('.env', generateEnv(demoGithub, false));
+		sv.file('.env.example', generateEnv(demoGithub, true));
+
+		sv.file(
+			`${directory.lib}/server/auth.${language}`,
+			transforms.script(({ ast, comments, js }) => {
+				js.imports.addNamed(ast, { from: '$lib/server/db', imports: [d1 ? 'getDb' : 'db'] });
+				js.imports.addNamed(ast, { from: '$app/server', imports: ['getRequestEvent'] });
+				js.imports.addNamed(ast, { from: '$env/dynamic/private', imports: ['env'] });
+				js.imports.addNamed(ast, {
+					from: 'better-auth/svelte-kit',
+					imports: ['sveltekitCookies']
+				});
+				js.imports.addNamed(ast, {
+					from: 'better-auth/adapters/drizzle',
+					imports: ['drizzleAdapter']
+				});
+				js.imports.addNamed(ast, { from: 'better-auth/minimal', imports: ['betterAuth'] });
+
+				const dialectMap: Record<Dialect, string> = {
+					mysql: 'mysql',
+					postgresql: 'pg',
+					sqlite: 'sqlite',
+					turso: 'sqlite'
+				};
+				const provider = dialectMap[drizzleDialect];
 
-			js.imports.addNamed(ast, { from: '$lib/server/db', imports: [d1 ? 'getDb' : 'db'] });
-			js.imports.addNamed(ast, { from: '$app/server', imports: ['getRequestEvent'] });
-			js.imports.addNamed(ast, { from: '$env/dynamic/private', imports: ['env'] });
-			js.imports.addNamed(ast, { from: 'better-auth/svelte-kit', imports: ['sveltekitCookies'] });
-			js.imports.addNamed(ast, {
-				from: 'better-auth/adapters/drizzle',
-				imports: ['drizzleAdapter']
-			});
-			js.imports.addNamed(ast, { from: 'better-auth/minimal', imports: ['betterAuth'] });
-
-			const dialectMap: Record<Dialect, string> = {
-				mysql: 'mysql',
-				postgresql: 'pg',
-				sqlite: 'sqlite',
-				turso: 'sqlite'
-			};
-			const provider = dialectMap[drizzleDialect];
-
-			const githubProvider = demoGithub
-				? `
+				const githubProvider = demoGithub
+					? `
 				socialProviders: {
 					github: {
 						clientId: env.GITHUB_CLIENT_ID,
 						clientSecret: env.GITHUB_CLIENT_SECRET,
 					},
 				},`
-				: '';
+					: '';
 
-			let authConfig = '';
-			if (d1) {
-				authConfig = dedent`
+				let authConfig = '';
+				if (d1) {
+					authConfig = dedent`
 					const authConfig = {
 						baseURL: env.ORIGIN,
 						secret: env.BETTER_AUTH_SECRET,
@@ -144,8 +149,8 @@ export default defineAddon({
 					 * To access \`auth\` at runtime, use \`event.locals.auth\`.
 					 */
 					export const auth = createAuth(${language === 'ts' ? 'null!' : 'null'});`;
-			} else {
-				authConfig = dedent`
+				} else {
+					authConfig = dedent`
 					export const auth = betterAuth({
 						baseURL: env.ORIGIN,
 						secret: env.BETTER_AUTH_SECRET,
@@ -157,97 +162,105 @@ export default defineAddon({
 							sveltekitCookies(getRequestEvent) // make sure this is the last plugin in the array
 						],
 					});`;
-			}
-			js.common.appendFromString(ast, { code: authConfig, comments });
-
-			return generateCode();
-		});
+				}
+				js.common.appendFromString(ast, { code: authConfig, comments });
+			})
+		);
 
 		const authConfigPath = `${directory.lib}/server/auth.${language}`;
 		const authSchemaPath = `${directory.lib}/server/db/auth.schema.${language}`;
 
-		sv.file(file.package, (content) => {
-			const { data, generateCode } = parse.json(content);
-			json.packageScriptsUpsert(
-				data,
-				'auth:schema',
-				`better-auth generate --config ${authConfigPath} --output ${authSchemaPath} --yes`
-			);
-			return generateCode();
-		});
-
-		sv.file(`${directory.lib}/server/db/auth.schema.${language}`, (content) => {
-			if (content) return content;
-			return dedent`
-				// If you see this file, you have not run the auth:schema script yet, but you should!
-			`;
-		});
-
-		sv.file(`${directory.lib}/server/db/schema.${language}`, (content) => {
-			const { ast, generateCode } = parse.script(content);
-
-			js.exports.addNamespace(ast, { from: './auth.schema' });
-
-			return generateCode();
-		});
-
-		sv.file('src/app.d.ts', (content) => {
-			const { ast, comments, generateCode } = parse.script(content);
-
-			if (d1) js.imports.addNamed(ast, { imports: ['createAuth'], from: '$lib/server/auth' });
-			js.imports.addNamed(ast, {
-				imports: ['User', 'Session'],
-				from: 'better-auth/minimal',
-				isType: true
-			});
-
-			const locals = js.kit.addGlobalAppInterface(ast, { name: 'Locals' });
-			if (!locals) {
-				throw new Error('Failed detecting `locals` interface in `src/app.d.ts`');
-			}
+		sv.file(
+			file.package,
+			transforms.json(({ data, json }) => {
+				json.packageScriptsUpsert(
+					data,
+					'auth:schema',
+					`better-auth generate --config ${authConfigPath} --output ${authSchemaPath} --yes`
+				);
+			})
+		);
 
-			// remove the commented out placeholder since we're adding the real one
-			comments.remove((c) => c.type === 'Line' && c.value.trim() === 'interface Locals {}');
+		sv.file(
+			`${directory.lib}/server/db/auth.schema.${language}`,
+			transforms.text(({ content }) => {
+				if (content) return false;
+				return dedent`
+					// If you see this file, you have not run the auth:schema script yet, but you should!
+				`;
+			})
+		);
+
+		sv.file(
+			`${directory.lib}/server/db/schema.${language}`,
+			transforms.script(({ ast, js }) => {
+				js.exports.addNamespace(ast, { from: './auth.schema' });
+			})
+		);
+
+		sv.file(
+			'src/app.d.ts',
+			transforms.script(({ ast, comments, js }) => {
+				if (d1) js.imports.addNamed(ast, { imports: ['createAuth'], from: '$lib/server/auth' });
+				js.imports.addNamed(ast, {
+					imports: ['User', 'Session'],
+					from: 'better-auth/minimal',
+					isType: true
+				});
+
+				const locals = js.kit.addGlobalAppInterface(ast, { name: 'Locals' });
+				if (!locals) {
+					throw new Error('Failed detecting `locals` interface in `src/app.d.ts`');
+				}
 
-			const user = locals.body.body.find((prop) =>
-				js.common.hasTypeProperty(prop, { name: 'user' })
-			);
-			const session = locals.body.body.find((prop) =>
-				js.common.hasTypeProperty(prop, { name: 'session' })
-			);
-			const auth = locals.body.body.find((prop) =>
-				js.common.hasTypeProperty(prop, { name: 'auth' })
-			);
+				// remove the commented out placeholder since we're adding the real one
+				comments.remove((c) => c.type === 'Line' && c.value.trim() === 'interface Locals {}');
 
-			if (!user) {
-				locals.body.body.push(js.common.createTypeProperty('user', 'User', true));
-			}
-			if (!session) {
-				locals.body.body.push(js.common.createTypeProperty('session', 'Session', true));
-			}
-			if (d1 && !auth) {
-				locals.body.body.push(
-					js.common.createTypeProperty('auth', 'ReturnType<typeof createAuth>', false)
+				const user = locals.body.body.find((prop) =>
+					js.common.hasTypeProperty(prop, { name: 'user' })
+				);
+				const session = locals.body.body.find((prop) =>
+					js.common.hasTypeProperty(prop, { name: 'session' })
+				);
+				const auth = locals.body.body.find((prop) =>
+					js.common.hasTypeProperty(prop, { name: 'auth' })
 				);
-			}
-			return generateCode();
-		});
-
-		sv.file(`src/hooks.server.${language}`, (content) => {
-			const { ast, generateCode, comments } = parse.script(content);
-
-			js.imports.addNamed(ast, { imports: ['svelteKitHandler'], from: 'better-auth/svelte-kit' });
-			js.imports.addNamed(ast, { imports: [d1 ? 'createAuth' : 'auth'], from: '$lib/server/auth' });
-			js.imports.addNamed(ast, { imports: ['building'], from: '$app/environment' });
 
-			const d1HandleSetup = d1
-				? dedent`
-					if (!event.platform?.env?.DB) throw new Error('D1 binding "DB" not found — are you running with wrangler?');
+				if (!user) {
+					locals.body.body.push(js.common.createTypeProperty('user', 'User', true));
+				}
+				if (!session) {
+					locals.body.body.push(js.common.createTypeProperty('session', 'Session', true));
+				}
+				if (d1 && !auth) {
+					locals.body.body.push(
+						js.common.createTypeProperty('auth', 'ReturnType<typeof createAuth>', false)
+					);
+				}
+			})
+		);
+
+		sv.file(
+			`src/hooks.server.${language}`,
+			transforms.script(({ ast, comments, js }) => {
+				js.imports.addNamed(ast, {
+					imports: ['svelteKitHandler'],
+					from: 'better-auth/svelte-kit'
+				});
+				js.imports.addNamed(ast, {
+					imports: [d1 ? 'createAuth' : 'auth'],
+					from: '$lib/server/auth'
+				});
+				js.imports.addNamed(ast, { imports: ['building'], from: '$app/environment' });
+
+				const d1HandleSetup = d1
+					? dedent`
+					if (!event.platform?.env?.DB) throw new Error('D1 binding "DB" not found - are you running with wrangler?');
 					event.locals.auth = createAuth(event.platform.env.DB);
 					const { auth } = event.locals;\n`
-				: '';
+					: '';
 
-			const handleContent = dedent`
+				const handleContent = dedent`
 				async ({ event, resolve }) => {${d1HandleSetup}
 					// Fetch current session from Better Auth
 					const session = await auth.api.getSession({
@@ -263,20 +276,17 @@ export default defineAddon({
 
 				export const handle = sequence(handleBetterAuth, handleSession);
 			`;
-			js.kit.addHooksHandle(ast, {
-				language,
-				newHandleName: 'handleBetterAuth',
-				handleContent,
-				comments
-			});
-
-			return generateCode();
-		});
+				js.kit.addHooksHandle(ast, {
+					language,
+					newHandleName: 'handleBetterAuth',
+					handleContent,
+					comments
+				});
+			})
+		);
 
 		if (hasDemo) {
-			sv.file(`${directory.kitRoutes}/demo/+page.svelte`, (content) => {
-				return addToDemoPage(content, 'better-auth', language);
-			});
+			sv.file(`${directory.kitRoutes}/demo/+page.svelte`, addToDemoPage('better-auth', language));
 
 			sv.file(
 				`${directory.kitRoutes}/demo/better-auth/login/+page.server.${language}`,
@@ -284,7 +294,7 @@ export default defineAddon({
 					if (content) {
 						const filePath = `${directory.kitRoutes}/demo/better-auth/login/+page.server.${language}`;
 						log.warn(`Existing ${color.warning(filePath)} file. Could not update.`);
-						return content;
+						return false;
 					}
 
 					const [ts] = createPrinter(language === 'ts');
@@ -388,7 +398,7 @@ export default defineAddon({
 				if (content) {
 					const filePath = `${directory.kitRoutes}/demo/better-auth/login/+page.svelte`;
 					log.warn(`Existing ${color.warning(filePath)} file. Could not update.`);
-					return content;
+					return false;
 				}
 
 				const tailwind = dependencyVersion('@tailwindcss/vite') !== undefined;
@@ -452,7 +462,7 @@ export default defineAddon({
 				if (content) {
 					const filePath = `${directory.kitRoutes}/demo/better-auth/+page.server.${language}`;
 					log.warn(`Existing ${color.warning(filePath)} file. Could not update.`);
-					return content;
+					return false;
 				}
 
 				const [ts] = createPrinter(language === 'ts');
@@ -485,7 +495,7 @@ export default defineAddon({
 				if (content) {
 					const filePath = `${directory.kitRoutes}/demo/better-auth/+page.svelte`;
 					log.warn(`Existing ${color.warning(filePath)} file. Could not update.`);
-					return content;
+					return false;
 				}
 
 				const tailwind = dependencyVersion('@tailwindcss/vite') !== undefined;
@@ -533,29 +543,30 @@ export default defineAddon({
 		return steps;
 	}
 });
-
-function generateEnvFileContent(content: string, demoGithub: boolean, isExample: boolean) {
-	content = text.upsert(content, 'ORIGIN', {
-		value: isExample ? `""` : `"http://localhost:5173"`,
-		separator: true
-	});
-	content = text.upsert(content, 'BETTER_AUTH_SECRET', {
-		value: isExample ? `""` : `"${crypto.randomUUID()}"`,
-		comment: [
-			'Better Auth',
-			'For production use 32 characters and generated with high entropy',
-			'https://www.better-auth.com/docs/installation'
-		],
-		separator: true
-	});
-
-	if (demoGithub) {
-		content = text.upsert(content, 'GITHUB_CLIENT_ID', {
-			value: `""`,
-			comment: 'GitHub OAuth\n# https://www.better-auth.com/docs/authentication/github'
+type GenerateEnv = (demoGithub: boolean, isExample: boolean) => TransformFn;
+const generateEnv: GenerateEnv = (demoGithub, isExample) =>
+	transforms.text(({ content, text }) => {
+		content = text.upsert(content, 'ORIGIN', {
+			value: isExample ? `""` : `"http://localhost:5173"`,
+			separator: true
+		});
+		content = text.upsert(content, 'BETTER_AUTH_SECRET', {
+			value: isExample ? `""` : `"${crypto.randomUUID()}"`,
+			comment: [
+				'Better Auth',
+				'For production use 32 characters and generated with high entropy',
+				'https://www.better-auth.com/docs/installation'
+			],
+			separator: true
 		});
-		content = text.upsert(content, 'GITHUB_CLIENT_SECRET', { value: `""` });
-	}
 
-	return content;
-}
+		if (demoGithub) {
+			content = text.upsert(content, 'GITHUB_CLIENT_ID', {
+				value: `""`,
+				comment: 'GitHub OAuth\n# https://www.better-auth.com/docs/authentication/github'
+			});
+			content = text.upsert(content, 'GITHUB_CLIENT_SECRET', { value: `""` });
+		}
+
+		return content;
+	});
diff --git a/packages/sv/src/addons/common.ts b/packages/sv/src/addons/common.ts
index 23605fe11..664dcdefc 100644
--- a/packages/sv/src/addons/common.ts
+++ b/packages/sv/src/addons/common.ts
@@ -1,9 +1,7 @@
-import { type SvelteAst, js, parse, svelte } from '@sveltejs/sv-utils';
+import { type SvelteAst, type TransformFn, transforms } from '@sveltejs/sv-utils';
 import process from 'node:process';
 
-export function addEslintConfigPrettier(content: string): string {
-	const { ast, generateCode } = parse.script(content);
-
+export const addEslintConfigPrettier = transforms.script(({ ast, js }) => {
 	// if a default import for `eslint-plugin-svelte` already exists, then we'll use their specifier's name instead
 	const importNodes = ast.body.filter((n) => n.type === 'ImportDeclaration');
 	const sveltePluginImport = importNodes.find(
@@ -28,7 +26,7 @@ export function addEslintConfigPrettier(content: string): string {
 	const defaultExport = js.exports.createDefault(ast, { fallback: fallbackConfig });
 	const eslintConfig = defaultExport.value;
 	if (eslintConfig.type !== 'ArrayExpression' && eslintConfig.type !== 'CallExpression')
-		return content;
+		return false;
 
 	const prettier = js.common.parseExpression('prettier');
 	const sveltePrettierConfig = js.common.parseExpression(`${svelteImportName}.configs.prettier`);
@@ -57,44 +55,34 @@ export function addEslintConfigPrettier(content: string): string {
 		// append to the end as a fallback
 		elements.push(...nodesToInsert);
 	}
-
-	return generateCode();
-}
-
-export function addToDemoPage(
-	existingContent: string,
-	path: string,
-	language: 'ts' | 'js'
-): string {
-	const { ast, generateCode } = parse.svelte(existingContent);
-
-	for (const node of ast.fragment.nodes) {
-		if (node.type === 'RegularElement') {
-			const hrefAttribute = node.attributes.find(
-				(x) => x.type === 'Attribute' && x.name === 'href'
-			) as SvelteAst.Attribute;
-			if (!hrefAttribute || !hrefAttribute.value) continue;
-
-			if (!Array.isArray(hrefAttribute.value)) continue;
-
-			const hasDemo = hrefAttribute.value.some(
-				// we use includes as it could be "/demo/${path}" or "resolve("demo/${path}")" or "resolve('demo/${path}')"
-				(x) => x.type === 'Text' && x.data.includes(`/demo/${path}`)
-			);
-			if (hasDemo) {
-				return existingContent;
+});
+
+type AddToDemoPage = (path: string, language: 'ts' | 'js') => TransformFn;
+export const addToDemoPage: AddToDemoPage = (path, language) =>
+	transforms.svelteScript({ language }, ({ ast, js, svelte }) => {
+		for (const node of ast.fragment.nodes) {
+			if (node.type === 'RegularElement') {
+				const hrefAttribute = node.attributes.find(
+					(x) => x.type === 'Attribute' && x.name === 'href'
+				) as SvelteAst.Attribute;
+				if (!hrefAttribute || !hrefAttribute.value) continue;
+
+				if (!Array.isArray(hrefAttribute.value)) continue;
+
+				const hasDemo = hrefAttribute.value.some(
+					// we use includes as it could be "/demo/${path}" or "resolve("demo/${path}")" or "resolve('demo/${path}')"
+					(x) => x.type === 'Text' && x.data.includes(`/demo/${path}`)
+				);
+				if (hasDemo) {
+					return false;
+				}
 			}
 		}
-	}
-
-	svelte.ensureScript(ast, { language });
-	js.imports.addNamed(ast.instance.content, { imports: ['resolve'], from: '$app/paths' });
 
-	svelte.addFragment(ast, `<a href={resolve('/demo/${path}')}>${path}</a>`, { mode: 'prepend' });
-	ast.fragment.nodes.unshift();
+		js.imports.addNamed(ast.instance.content, { imports: ['resolve'], from: '$app/paths' });
 
-	return generateCode();
-}
+		svelte.addFragment(ast, `<a href={resolve('/demo/${path}')}>${path}</a>`, { mode: 'prepend' });
+	});
 
 /**
  * Returns the corresponding `@types/node` version for the version of Node.js running in the current process.
diff --git a/packages/sv/src/addons/devtools-json.ts b/packages/sv/src/addons/devtools-json.ts
index 156edd16a..311f631e0 100644
--- a/packages/sv/src/addons/devtools-json.ts
+++ b/packages/sv/src/addons/devtools-json.ts
@@ -1,4 +1,4 @@
-import { js, parse } from '@sveltejs/sv-utils';
+import { transforms } from '@sveltejs/sv-utils';
 import { defineAddon } from '../core/config.ts';
 
 export default defineAddon({
@@ -11,14 +11,13 @@ export default defineAddon({
 		sv.devDependency('vite-plugin-devtools-json', '^1.0.0');
 
 		// add the vite plugin
-		sv.file(file.viteConfig, (content) => {
-			const { ast, generateCode } = parse.script(content);
-
-			const vitePluginName = 'devtoolsJson';
-			js.imports.addDefault(ast, { as: vitePluginName, from: 'vite-plugin-devtools-json' });
-			js.vite.addPlugin(ast, { code: `${vitePluginName}()` });
-
-			return generateCode();
-		});
+		sv.file(
+			file.viteConfig,
+			transforms.script(({ ast, js }) => {
+				const vitePluginName = 'devtoolsJson';
+				js.imports.addDefault(ast, { as: vitePluginName, from: 'vite-plugin-devtools-json' });
+				js.vite.addPlugin(ast, { code: `${vitePluginName}()` });
+			})
+		);
 	}
 });
diff --git a/packages/sv/src/addons/drizzle.ts b/packages/sv/src/addons/drizzle.ts
index 5aab71380..621191057 100644
--- a/packages/sv/src/addons/drizzle.ts
+++ b/packages/sv/src/addons/drizzle.ts
@@ -1,11 +1,9 @@
 import {
 	color,
 	dedent,
-	text,
-	js,
-	parse,
+	type TransformFn,
+	transforms,
 	resolveCommand,
-	json,
 	fileExists
 } from '@sveltejs/sv-utils';
 import crypto from 'node:crypto';
@@ -92,7 +90,7 @@ export default defineAddon({
 	},
 	run: ({ sv, language, options, directory, dependencyVersion, cwd, cancel, file }) => {
 		if (options.database === 'd1' && !dependencyVersion('@sveltejs/adapter-cloudflare')) {
-			return cancel('Cloudflare D1 requires @sveltejs/adapter-cloudflare — add the adapter first');
+			return cancel('Cloudflare D1 requires @sveltejs/adapter-cloudflare - add the adapter first');
 		}
 
 		const typescript = language === 'ts';
@@ -131,22 +129,25 @@ export default defineAddon({
 		if (options.sqlite === 'libsql' || options.sqlite === 'turso')
 			sv.devDependency('@libsql/client', '^0.17.0');
 
-		sv.file('.env', (content) => generateEnvFileContent(content, options, false));
-		sv.file('.env.example', (content) => generateEnvFileContent(content, options, true));
+		sv.file('.env', generateEnv(options, false));
+		sv.file('.env.example', generateEnv(options, true));
 
 		if (options.docker && (options.mysql === 'mysql2' || options.postgresql === 'postgres.js')) {
-			const composeFileOptions = ['docker-compose.yml', 'docker-compose.yaml', 'compose.yaml'];
-			let composeFile = '';
-			for (const option of composeFileOptions) {
-				composeFile = option;
-				if (fs.existsSync(path.resolve(cwd, option))) break;
-			}
-			if (composeFile === '') throw new Error('unreachable state...');
+			const composeFileOptions = [
+				// First item has higher priority
+				'compose.yaml', // canonical name
+				'compose.yml',
+				'docker-compose.yaml', // for backward compatibility
+				'docker-compose.yml' // for backward compatibility
+			];
+
+			const composeFile =
+				composeFileOptions.find((option) => fs.existsSync(path.resolve(cwd, option))) ??
+				'compose.yaml';
 
 			sv.file(composeFile, (content) => {
-				// if the file already exists, don't modify it
-				// (in the future, we could add some tooling for modifying yaml)
-				if (content.length > 0) return content;
+				// `transforms.yaml` not implemented. Therefore, abort if file exist.
+				if (content.length > 0) return false;
 
 				const imageName = options.database === 'mysql' ? 'mysql' : 'postgres';
 				const port = PORTS[options.database];
@@ -178,7 +179,7 @@ export default defineAddon({
                 `;
 				}
 
-				content = dedent`
+				return dedent`
                 services:
                   db:
                     image: ${imageName}
@@ -187,86 +188,90 @@ export default defineAddon({
                       - ${port}:${port}
                     environment: ${dbSpecificContent}
                 `;
-
-				return content;
 			});
 		}
 
-		sv.file(file.package, (content) => {
-			const { data, generateCode } = parse.json(content);
-
-			if (options.docker) json.packageScriptsUpsert(data, 'db:start', 'docker compose up');
-			json.packageScriptsUpsert(data, 'db:push', 'drizzle-kit push');
-			json.packageScriptsUpsert(data, 'db:generate', 'drizzle-kit generate');
-			json.packageScriptsUpsert(data, 'db:migrate', 'drizzle-kit migrate');
-			json.packageScriptsUpsert(data, 'db:studio', 'drizzle-kit studio');
-
-			return generateCode();
-		});
+		sv.file(
+			file.package,
+			transforms.json(({ data, json }) => {
+				if (options.docker) json.packageScriptsUpsert(data, 'db:start', 'docker compose up');
+				json.packageScriptsUpsert(data, 'db:push', 'drizzle-kit push');
+				json.packageScriptsUpsert(data, 'db:generate', 'drizzle-kit generate');
+				json.packageScriptsUpsert(data, 'db:migrate', 'drizzle-kit migrate');
+				json.packageScriptsUpsert(data, 'db:studio', 'drizzle-kit studio');
+			})
+		);
 
 		const hasPrettier = Boolean(dependencyVersion('prettier'));
 		if (hasPrettier) {
-			sv.file(file.prettierignore, (content) => {
-				return text.upsert(content, '/drizzle/');
-			});
+			sv.file(
+				file.prettierignore,
+				transforms.text(({ content, text }) => text.upsert(content, '/drizzle/'))
+			);
 		}
 
 		if (options.database === 'sqlite') {
-			sv.file(file.gitignore, (content) => {
-				if (content.length === 0) return content;
-				return text.upsert(content, '*.db', { comment: 'SQLite' });
-			});
+			sv.file(
+				file.gitignore,
+				transforms.text(({ content, text }) => {
+					if (content.length === 0) return false;
+					return text.upsert(content, '*.db', { comment: 'SQLite' });
+				})
+			);
 		}
 
-		sv.file(paths['drizzle config'], (content) => {
-			const d1 = options.database === 'd1';
-			const turso = options.sqlite === 'turso';
-
-			const { ast, generateCode } = parse.script(content);
-
-			js.imports.addNamed(ast, { from: 'drizzle-kit', imports: { defineConfig: 'defineConfig' } });
-
-			if (d1) {
-				ast.body.push(
-					js.common.parseStatement(
-						"if (!process.env.CLOUDFLARE_ACCOUNT_ID) throw new Error('CLOUDFLARE_ACCOUNT_ID is not set');"
-					),
-					js.common.parseStatement(
-						"if (!process.env.CLOUDFLARE_DATABASE_ID) throw new Error('CLOUDFLARE_DATABASE_ID is not set');"
-					),
-					js.common.parseStatement(
-						"if (!process.env.CLOUDFLARE_D1_TOKEN) throw new Error('CLOUDFLARE_D1_TOKEN is not set');"
-					)
-				);
-			} else {
-				ast.body.push(
-					js.common.parseStatement(
-						"if (!process.env.DATABASE_URL) throw new Error('DATABASE_URL is not set');"
-					)
-				);
-			}
+		sv.file(
+			paths['drizzle config'],
+			transforms.script(({ ast, js }) => {
+				const d1 = options.database === 'd1';
+				const turso = options.sqlite === 'turso';
 
-			const getDialect = (): string => {
-				if (d1) return 'sqlite';
-				if (turso) return 'turso';
-				return options.database;
-			};
+				js.imports.addNamed(ast, {
+					from: 'drizzle-kit',
+					imports: { defineConfig: 'defineConfig' }
+				});
 
-			const getCredentials = (): string => {
-				const creds: string[] = [];
 				if (d1) {
-					creds.push('accountId: process.env.CLOUDFLARE_ACCOUNT_ID,');
-					creds.push('databaseId: process.env.CLOUDFLARE_DATABASE_ID,');
-					creds.push('token: process.env.CLOUDFLARE_D1_TOKEN,');
+					ast.body.push(
+						js.common.parseStatement(
+							"if (!process.env.CLOUDFLARE_ACCOUNT_ID) throw new Error('CLOUDFLARE_ACCOUNT_ID is not set');"
+						),
+						js.common.parseStatement(
+							"if (!process.env.CLOUDFLARE_DATABASE_ID) throw new Error('CLOUDFLARE_DATABASE_ID is not set');"
+						),
+						js.common.parseStatement(
+							"if (!process.env.CLOUDFLARE_D1_TOKEN) throw new Error('CLOUDFLARE_D1_TOKEN is not set');"
+						)
+					);
+				} else {
+					ast.body.push(
+						js.common.parseStatement(
+							"if (!process.env.DATABASE_URL) throw new Error('DATABASE_URL is not set');"
+						)
+					);
 				}
-				if (turso) creds.push('authToken: process.env.DATABASE_AUTH_TOKEN,');
-				if (!d1) creds.push('url: process.env.DATABASE_URL,');
 
-				return creds.join('\n');
-			};
-
-			js.exports.createDefault(ast, {
-				fallback: js.common.parseExpression(`
+				const getDialect = (): string => {
+					if (d1) return 'sqlite';
+					if (turso) return 'turso';
+					return options.database;
+				};
+
+				const getCredentials = (): string => {
+					const creds: string[] = [];
+					if (d1) {
+						creds.push('accountId: process.env.CLOUDFLARE_ACCOUNT_ID,');
+						creds.push('databaseId: process.env.CLOUDFLARE_DATABASE_ID,');
+						creds.push('token: process.env.CLOUDFLARE_D1_TOKEN,');
+					}
+					if (turso) creds.push('authToken: process.env.DATABASE_AUTH_TOKEN,');
+					if (!d1) creds.push('url: process.env.DATABASE_URL,');
+
+					return creds.join('\n');
+				};
+
+				js.exports.createDefault(ast, {
+					fallback: js.common.parseExpression(`
 					defineConfig({
 						schema: "./${directory.lib}/server/db/schema.${language}",
 						dialect: "${getDialect()}",
@@ -278,200 +283,197 @@ export default defineAddon({
 						strict: true
 					})
 				`)
-			});
-
-			return generateCode();
-		});
-
-		sv.file(paths['database schema'], (content) => {
-			const { ast, generateCode } = parse.script(content);
-
-			let taskSchemaExpression;
-			if (options.database === 'sqlite' || options.database === 'd1') {
-				js.imports.addNamed(ast, {
-					from: 'drizzle-orm/sqlite-core',
-					imports: ['integer', 'sqliteTable', 'text']
 				});
+			})
+		);
 
-				taskSchemaExpression = js.common.parseExpression(`sqliteTable('task', {
+		sv.file(
+			paths['database schema'],
+			transforms.script(({ ast, js }) => {
+				let taskSchemaExpression;
+				if (options.database === 'sqlite' || options.database === 'd1') {
+					js.imports.addNamed(ast, {
+						from: 'drizzle-orm/sqlite-core',
+						imports: ['integer', 'sqliteTable', 'text']
+					});
+
+					taskSchemaExpression = js.common.parseExpression(`sqliteTable('task', {
 				id: text('id').primaryKey().$defaultFn(() => crypto.randomUUID()),
 				title: text('title').notNull(),
 				priority: integer('priority').notNull().default(1)
 			})`);
-			}
-			if (options.database === 'mysql') {
-				js.imports.addNamed(ast, {
-					from: 'drizzle-orm/mysql-core',
-					imports: ['mysqlTable', 'serial', 'int', 'text']
-				});
+				}
+				if (options.database === 'mysql') {
+					js.imports.addNamed(ast, {
+						from: 'drizzle-orm/mysql-core',
+						imports: ['mysqlTable', 'serial', 'int', 'text']
+					});
 
-				taskSchemaExpression = js.common.parseExpression(`mysqlTable('task', {
+					taskSchemaExpression = js.common.parseExpression(`mysqlTable('task', {
 				id: serial('id').primaryKey(),
 				title: text('title').notNull(),
 				priority: int('priority').notNull().default(1)
 			})`);
-			}
-			if (options.database === 'postgresql') {
-				js.imports.addNamed(ast, {
-					from: 'drizzle-orm/pg-core',
-					imports: ['pgTable', 'serial', 'integer', 'text']
-				});
+				}
+				if (options.database === 'postgresql') {
+					js.imports.addNamed(ast, {
+						from: 'drizzle-orm/pg-core',
+						imports: ['pgTable', 'serial', 'integer', 'text']
+					});
 
-				taskSchemaExpression = js.common.parseExpression(`pgTable('task', {
+					taskSchemaExpression = js.common.parseExpression(`pgTable('task', {
 				id: serial('id').primaryKey(),
 				title: text('title').notNull(),
 				priority: integer('priority').notNull().default(1)
 			})`);
-			}
+				}
 
-			if (!taskSchemaExpression) throw new Error('unreachable state...');
-			const taskIdentifier = js.variables.declaration(ast, {
-				kind: 'const',
-				name: 'task',
-				value: taskSchemaExpression
-			});
-			js.exports.createNamed(ast, {
-				name: 'task',
-				fallback: taskIdentifier
-			});
+				if (!taskSchemaExpression) throw new Error('unreachable state...');
+				const taskIdentifier = js.variables.declaration(ast, {
+					kind: 'const',
+					name: 'task',
+					value: taskSchemaExpression
+				});
+				js.exports.createNamed(ast, {
+					name: 'task',
+					fallback: taskIdentifier
+				});
+			})
+		);
+
+		sv.file(
+			paths.database,
+			transforms.script(({ ast, js }) => {
+				if (options.database === 'd1') {
+					js.imports.addNamespace(ast, { from: './schema', as: 'schema' });
+					js.imports.addNamed(ast, { from: 'drizzle-orm/d1', imports: ['drizzle'] });
 
-			return generateCode();
-		});
+					const getDbFn = js.common.parseStatement(
+						`export const getDb = (d1${typescript ? ': D1Database' : ''}) => drizzle(d1, { schema });`
+					);
+
+					ast.body.push(getDbFn);
 
-		sv.file(paths.database, (content) => {
-			const { ast, generateCode } = parse.script(content);
+					return;
+				}
 
-			if (options.database === 'd1') {
+				js.imports.addNamed(ast, { from: '$env/dynamic/private', imports: ['env'] });
 				js.imports.addNamespace(ast, { from: './schema', as: 'schema' });
-				js.imports.addNamed(ast, { from: 'drizzle-orm/d1', imports: ['drizzle'] });
 
-				const getDbFn = js.common.parseStatement(
-					`export const getDb = (d1${typescript ? ': D1Database' : ''}) => drizzle(d1, { schema });`
+				// env var checks
+				const dbURLCheck = js.common.parseStatement(
+					"if (!env.DATABASE_URL) throw new Error('DATABASE_URL is not set');"
 				);
+				ast.body.push(dbURLCheck);
+
+				let clientExpression;
+				// SQLite
+				if (options.sqlite === 'better-sqlite3') {
+					js.imports.addDefault(ast, { from: 'better-sqlite3', as: 'Database' });
+					js.imports.addNamed(ast, {
+						from: 'drizzle-orm/better-sqlite3',
+						imports: ['drizzle']
+					});
+
+					clientExpression = js.common.parseExpression('new Database(env.DATABASE_URL)');
+				}
+				if (options.sqlite === 'libsql' || options.sqlite === 'turso') {
+					js.imports.addNamed(ast, {
+						from: '@libsql/client',
+						imports: ['createClient']
+					});
+					js.imports.addNamed(ast, {
+						from: 'drizzle-orm/libsql',
+						imports: ['drizzle']
+					});
+
+					if (options.sqlite === 'turso') {
+						ast.body.push(
+							js.common.parseStatement(
+								"if (!env.DATABASE_AUTH_TOKEN) throw new Error('DATABASE_AUTH_TOKEN is not set');"
+							)
+						);
+						clientExpression = js.common.parseExpression(
+							'createClient({ url: env.DATABASE_URL, authToken: env.DATABASE_AUTH_TOKEN })'
+						);
+					} else {
+						clientExpression = js.common.parseExpression('createClient({ url: env.DATABASE_URL })');
+					}
+				}
+				// MySQL
+				if (options.mysql === 'mysql2' || options.mysql === 'planetscale') {
+					js.imports.addDefault(ast, { from: 'mysql2/promise', as: 'mysql' });
+					js.imports.addNamed(ast, {
+						from: 'drizzle-orm/mysql2',
+						imports: ['drizzle']
+					});
+
+					clientExpression = js.common.parseExpression('mysql.createPool(env.DATABASE_URL)');
+				}
+				// PostgreSQL
+				if (options.postgresql === 'neon') {
+					js.imports.addNamed(ast, {
+						from: '@neondatabase/serverless',
+						imports: ['neon']
+					});
+					js.imports.addNamed(ast, {
+						from: 'drizzle-orm/neon-http',
+						imports: ['drizzle']
+					});
+
+					clientExpression = js.common.parseExpression('neon(env.DATABASE_URL)');
+				}
+				if (options.postgresql === 'postgres.js') {
+					js.imports.addDefault(ast, { from: 'postgres', as: 'postgres' });
+					js.imports.addNamed(ast, {
+						from: 'drizzle-orm/postgres-js',
+						imports: ['drizzle']
+					});
 
-				ast.body.push(getDbFn);
-
-				return generateCode();
-			}
-
-			js.imports.addNamed(ast, { from: '$env/dynamic/private', imports: ['env'] });
-			js.imports.addNamespace(ast, { from: './schema', as: 'schema' });
+					clientExpression = js.common.parseExpression('postgres(env.DATABASE_URL)');
+				}
 
-			// env var checks
-			const dbURLCheck = js.common.parseStatement(
-				"if (!env.DATABASE_URL) throw new Error('DATABASE_URL is not set');"
-			);
-			ast.body.push(dbURLCheck);
+				if (!clientExpression) throw new Error('unreachable state...');
+				ast.body.push(
+					js.variables.declaration(ast, {
+						kind: 'const',
+						name: 'client',
+						value: clientExpression
+					})
+				);
 
-			let clientExpression;
-			// SQLite
-			if (options.sqlite === 'better-sqlite3') {
-				js.imports.addDefault(ast, { from: 'better-sqlite3', as: 'Database' });
-				js.imports.addNamed(ast, {
-					from: 'drizzle-orm/better-sqlite3',
-					imports: ['drizzle']
+				// create drizzle function call
+				const drizzleCall = js.functions.createCall({
+					name: 'drizzle',
+					args: ['client'],
+					useIdentifiers: true
 				});
 
-				clientExpression = js.common.parseExpression('new Database(env.DATABASE_URL)');
-			}
-			if (options.sqlite === 'libsql' || options.sqlite === 'turso') {
-				js.imports.addNamed(ast, {
-					from: '@libsql/client',
-					imports: ['createClient']
-				});
-				js.imports.addNamed(ast, {
-					from: 'drizzle-orm/libsql',
-					imports: ['drizzle']
+				// add schema to support `db.query`
+				const paramObject = js.object.create({
+					schema: js.variables.createIdentifier('schema')
 				});
-
-				if (options.sqlite === 'turso') {
-					ast.body.push(
-						js.common.parseStatement(
-							"if (!env.DATABASE_AUTH_TOKEN) throw new Error('DATABASE_AUTH_TOKEN is not set');"
-						)
-					);
-					clientExpression = js.common.parseExpression(
-						'createClient({ url: env.DATABASE_URL, authToken: env.DATABASE_AUTH_TOKEN })'
-					);
-				} else {
-					clientExpression = js.common.parseExpression('createClient({ url: env.DATABASE_URL })');
+				if (options.database === 'mysql') {
+					const mode = options.mysql === 'planetscale' ? 'planetscale' : 'default';
+					js.object.property(paramObject, {
+						name: 'mode',
+						fallback: js.common.createLiteral(mode)
+					});
 				}
-			}
-			// MySQL
-			if (options.mysql === 'mysql2' || options.mysql === 'planetscale') {
-				js.imports.addDefault(ast, { from: 'mysql2/promise', as: 'mysql' });
-				js.imports.addNamed(ast, {
-					from: 'drizzle-orm/mysql2',
-					imports: ['drizzle']
-				});
-
-				clientExpression = js.common.parseExpression('mysql.createPool(env.DATABASE_URL)');
-			}
-			// PostgreSQL
-			if (options.postgresql === 'neon') {
-				js.imports.addNamed(ast, {
-					from: '@neondatabase/serverless',
-					imports: ['neon']
-				});
-				js.imports.addNamed(ast, {
-					from: 'drizzle-orm/neon-http',
-					imports: ['drizzle']
-				});
-
-				clientExpression = js.common.parseExpression('neon(env.DATABASE_URL)');
-			}
-			if (options.postgresql === 'postgres.js') {
-				js.imports.addDefault(ast, { from: 'postgres', as: 'postgres' });
-				js.imports.addNamed(ast, {
-					from: 'drizzle-orm/postgres-js',
-					imports: ['drizzle']
-				});
-
-				clientExpression = js.common.parseExpression('postgres(env.DATABASE_URL)');
-			}
+				drizzleCall.arguments.push(paramObject);
 
-			if (!clientExpression) throw new Error('unreachable state...');
-			ast.body.push(
-				js.variables.declaration(ast, {
+				// create `db` export
+				const db = js.variables.declaration(ast, {
 					kind: 'const',
-					name: 'client',
-					value: clientExpression
-				})
-			);
-
-			// create drizzle function call
-			const drizzleCall = js.functions.createCall({
-				name: 'drizzle',
-				args: ['client'],
-				useIdentifiers: true
-			});
-
-			// add schema to support `db.query`
-			const paramObject = js.object.create({
-				schema: js.variables.createIdentifier('schema')
-			});
-			if (options.database === 'mysql') {
-				const mode = options.mysql === 'planetscale' ? 'planetscale' : 'default';
-				js.object.property(paramObject, {
-					name: 'mode',
-					fallback: js.common.createLiteral(mode)
+					name: 'db',
+					value: drizzleCall
 				});
-			}
-			drizzleCall.arguments.push(paramObject);
-
-			// create `db` export
-			const db = js.variables.declaration(ast, {
-				kind: 'const',
-				name: 'db',
-				value: drizzleCall
-			});
-			js.exports.createNamed(ast, {
-				name: 'db',
-				fallback: db
-			});
-
-			return generateCode();
-		});
+				js.exports.createNamed(ast, {
+					name: 'db',
+					fallback: db
+				});
+			})
+		);
 	},
 
 	nextSteps: ({ options, packageManager, cwd }) => {
@@ -513,68 +515,66 @@ export default defineAddon({
 	}
 });
 
-function generateEnvFileContent(
-	content: string,
-	opts: OptionValues<typeof options>,
-	isExample: boolean
-) {
-	const DB_URL_KEY = 'DATABASE_URL';
-
-	if (opts.database === 'd1') {
-		content = text.upsert(content, 'CLOUDFLARE_ACCOUNT_ID', {
-			value: '""',
-			comment: ['Cloudflare D1'],
-			separator: true
-		});
-		content = text.upsert(content, 'CLOUDFLARE_DATABASE_ID', { value: '""' });
-		content = text.upsert(content, 'CLOUDFLARE_D1_TOKEN', { value: '""' });
-		return content;
-	}
+type GenerateEnv = (opts: OptionValues<typeof options>, isExample: boolean) => TransformFn;
+const generateEnv: GenerateEnv = (opts, isExample) =>
+	transforms.text(({ content, text }) => {
+		const DB_URL_KEY = 'DATABASE_URL';
 
-	// Calculate value and comment based on database options
-	let value: string;
-	const comment: NonNullable<Parameters<typeof text.upsert>[2]>['comment'] = ['Drizzle'];
-
-	if (opts.docker) {
-		const protocol = opts.database === 'mysql' ? 'mysql' : 'postgres';
-		const port = PORTS[opts.database];
-		value = `"${protocol}://root:mysecretpassword@localhost:${port}/local"`;
-	} else if (opts.sqlite === 'better-sqlite3' || opts.sqlite === 'libsql') {
-		value = opts.sqlite === 'libsql' ? 'file:local.db' : 'local.db';
-	} else if (opts.sqlite === 'turso') {
-		if (isExample) {
-			value = '"libsql://db-name-user.turso.io"';
-			comment.push(
-				'Replace with your DB credentials!',
-				{ text: 'A local DB can also be used in dev as well', mode: 'append' },
-				{ text: `${DB_URL_KEY}="file:local.db"`, mode: 'append' }
-			);
+		if (opts.database === 'd1') {
+			content = text.upsert(content, 'CLOUDFLARE_ACCOUNT_ID', {
+				value: '""',
+				comment: ['Cloudflare D1'],
+				separator: true
+			});
+			content = text.upsert(content, 'CLOUDFLARE_DATABASE_ID', { value: '""' });
+			content = text.upsert(content, 'CLOUDFLARE_D1_TOKEN', { value: '""' });
+			return content;
+		}
+
+		// Calculate value and comment based on database options
+		let value: string;
+		const comment: NonNullable<Parameters<typeof text.upsert>[2]>['comment'] = ['Drizzle'];
+
+		if (opts.docker) {
+			const protocol = opts.database === 'mysql' ? 'mysql' : 'postgres';
+			const port = PORTS[opts.database];
+			value = `"${protocol}://root:mysecretpassword@localhost:${port}/local"`;
+		} else if (opts.sqlite === 'better-sqlite3' || opts.sqlite === 'libsql') {
+			value = opts.sqlite === 'libsql' ? 'file:local.db' : 'local.db';
+		} else if (opts.sqlite === 'turso') {
+			if (isExample) {
+				value = '"libsql://db-name-user.turso.io"';
+				comment.push(
+					'Replace with your DB credentials!',
+					{ text: 'A local DB can also be used in dev as well', mode: 'append' },
+					{ text: `${DB_URL_KEY}="file:local.db"`, mode: 'append' }
+				);
+			} else {
+				value = '"file:local.db"';
+				comment.push(
+					'Replace with your DB credentials!',
+					`${DB_URL_KEY}="libsql://db-name-user.turso.io"`,
+					'A local DB can also be used in dev as well'
+				);
+			}
+		} else if (opts.database === 'mysql') {
+			value = '"mysql://user:password@host:port/db-name"';
+			comment.push('Replace with your DB credentials!');
+		} else if (opts.database === 'postgresql') {
+			value = '"postgres://user:password@host:port/db-name"';
+			comment.push('Replace with your DB credentials!');
 		} else {
-			value = '"file:local.db"';
-			comment.push(
-				'Replace with your DB credentials!',
-				`${DB_URL_KEY}="libsql://db-name-user.turso.io"`,
-				'A local DB can also be used in dev as well'
-			);
+			value = '';
 		}
-	} else if (opts.database === 'mysql') {
-		value = '"mysql://user:password@host:port/db-name"';
-		comment.push('Replace with your DB credentials!');
-	} else if (opts.database === 'postgresql') {
-		value = '"postgres://user:password@host:port/db-name"';
-		comment.push('Replace with your DB credentials!');
-	} else {
-		value = '';
-	}
 
-	content = text.upsert(content, DB_URL_KEY, { value, comment, separator: true });
+		content = text.upsert(content, DB_URL_KEY, { value, comment, separator: true });
 
-	// Turso requires an auth token
-	if (opts.sqlite === 'turso') {
-		content = text.upsert(content, 'DATABASE_AUTH_TOKEN', {
-			value: isExample ? `""` : `"${crypto.randomUUID()}"`
-		});
-	}
+		// Turso requires an auth token
+		if (opts.sqlite === 'turso') {
+			content = text.upsert(content, 'DATABASE_AUTH_TOKEN', {
+				value: isExample ? `""` : `"${crypto.randomUUID()}"`
+			});
+		}
 
-	return content;
-}
+		return content;
+	});
diff --git a/packages/sv/src/addons/eslint.ts b/packages/sv/src/addons/eslint.ts
index feea56524..45855a28c 100644
--- a/packages/sv/src/addons/eslint.ts
+++ b/packages/sv/src/addons/eslint.ts
@@ -1,5 +1,5 @@
 import { log } from '@clack/prompts';
-import { type AstTypes, js, parse, json } from '@sveltejs/sv-utils';
+import { type AstTypes, transforms } from '@sveltejs/sv-utils';
 import { defineAddon } from '../core/config.ts';
 import { addEslintConfigPrettier, getNodeTypesVersion } from './common.ts';
 
@@ -23,128 +23,127 @@ export default defineAddon({
 
 		if (prettierInstalled) sv.devDependency('eslint-config-prettier', '^10.1.8');
 
-		sv.file(file.package, (content) => {
-			const { data, generateCode } = parse.json(content);
-
-			json.packageScriptsUpsert(data, 'lint', 'eslint .');
-
-			return generateCode();
-		});
-
-		sv.file(file.eslintConfig, (content) => {
-			const { ast, comments, generateCode } = parse.script(content);
-
-			const eslintConfigs: Array<AstTypes.Expression | AstTypes.SpreadElement> = [];
-			js.imports.addDefault(ast, { from: './svelte.config.js', as: 'svelteConfig' });
-			const gitIgnorePathStatement = js.common.parseStatement(
-				"\nconst gitignorePath = path.resolve(import.meta.dirname, '.gitignore');"
-			);
-			js.common.appendStatement(ast, { statement: gitIgnorePathStatement });
-
-			const ignoresConfig = js.common.parseExpression('includeIgnoreFile(gitignorePath)');
-			eslintConfigs.push(ignoresConfig);
-
-			const jsConfig = js.common.parseExpression('js.configs.recommended');
-			eslintConfigs.push(jsConfig);
-
-			if (typescript) {
-				const tsConfig = js.common.parseExpression('ts.configs.recommended');
-				eslintConfigs.push(tsConfig);
-			}
-
-			const svelteConfig = js.common.parseExpression('svelte.configs.recommended');
-			eslintConfigs.push(svelteConfig);
-
-			const globalsBrowser = js.common.createSpread(js.common.parseExpression('globals.browser'));
-			const globalsNode = js.common.createSpread(js.common.parseExpression('globals.node'));
-			const globalsObjLiteral = js.object.create({});
-			globalsObjLiteral.properties = [globalsBrowser, globalsNode];
-			const rules = js.object.create({ '"no-undef"': 'off' });
-
-			if (rules.properties[0].type !== 'Property') {
-				throw new Error('rules.properties[0].type !== "Property"');
-			}
-			comments.add(rules.properties[0].key, {
-				type: 'Line',
-				value:
-					' typescript-eslint strongly recommend that you do not use the no-undef lint rule on TypeScript projects.'
-			});
-			comments.add(rules.properties[0].key, {
-				type: 'Line',
-				value:
-					' see: https://typescript-eslint.io/troubleshooting/faqs/eslint/#i-get-errors-from-the-no-undef-rule-about-global-variables-not-being-defined-even-though-there-are-no-typescript-errors'
-			});
-
-			const globalsConfig = js.object.create({
-				languageOptions: {
-					globals: globalsObjLiteral
-				},
-				rules: typescript ? rules : undefined
-			});
-
-			eslintConfigs.push(globalsConfig);
-
-			if (typescript) {
-				const svelteTSParserConfig = js.object.create({
-					files: ['**/*.svelte', '**/*.svelte.ts', '**/*.svelte.js'],
-					languageOptions: {
-						parserOptions: {
-							projectService: true,
-							extraFileExtensions: ['.svelte'],
-							parser: js.variables.createIdentifier('ts.parser'),
-							svelteConfig: js.variables.createIdentifier('svelteConfig')
-						}
-					}
+		sv.file(
+			file.package,
+			transforms.json(({ data, json }) => {
+				json.packageScriptsUpsert(data, 'lint', 'eslint .');
+			})
+		);
+
+		sv.file(
+			file.eslintConfig,
+			transforms.script(({ ast, comments, js }) => {
+				const eslintConfigs: Array<AstTypes.Expression | AstTypes.SpreadElement> = [];
+				js.imports.addDefault(ast, { from: './svelte.config.js', as: 'svelteConfig' });
+				const gitIgnorePathStatement = js.common.parseStatement(
+					"\nconst gitignorePath = path.resolve(import.meta.dirname, '.gitignore');"
+				);
+				js.common.appendStatement(ast, { statement: gitIgnorePathStatement });
+
+				const ignoresConfig = js.common.parseExpression('includeIgnoreFile(gitignorePath)');
+				eslintConfigs.push(ignoresConfig);
+
+				const jsConfig = js.common.parseExpression('js.configs.recommended');
+				eslintConfigs.push(jsConfig);
+
+				if (typescript) {
+					const tsConfig = js.common.parseExpression('ts.configs.recommended');
+					eslintConfigs.push(tsConfig);
+				}
+
+				const svelteConfig = js.common.parseExpression('svelte.configs.recommended');
+				eslintConfigs.push(svelteConfig);
+
+				const globalsBrowser = js.common.createSpread(js.common.parseExpression('globals.browser'));
+				const globalsNode = js.common.createSpread(js.common.parseExpression('globals.node'));
+				const globalsObjLiteral = js.object.create({});
+				globalsObjLiteral.properties = [globalsBrowser, globalsNode];
+				const rules = js.object.create({ '"no-undef"': 'off' });
+
+				if (rules.properties[0].type !== 'Property') {
+					throw new Error('rules.properties[0].type !== "Property"');
+				}
+				comments.add(rules.properties[0].key, {
+					type: 'Line',
+					value:
+						' typescript-eslint strongly recommend that you do not use the no-undef lint rule on TypeScript projects.'
 				});
-				eslintConfigs.push(svelteTSParserConfig);
-			} else {
-				const svelteTSParserConfig = js.object.create({
-					files: ['**/*.svelte', '**/*.svelte.js'],
+				comments.add(rules.properties[0].key, {
+					type: 'Line',
+					value:
+						' see: https://typescript-eslint.io/troubleshooting/faqs/eslint/#i-get-errors-from-the-no-undef-rule-about-global-variables-not-being-defined-even-though-there-are-no-typescript-errors'
+				});
+
+				const globalsConfig = js.object.create({
 					languageOptions: {
-						parserOptions: {
-							svelteConfig: js.variables.createIdentifier('svelteConfig')
+						globals: globalsObjLiteral
+					},
+					rules: typescript ? rules : undefined
+				});
+
+				eslintConfigs.push(globalsConfig);
+
+				if (typescript) {
+					const svelteTSParserConfig = js.object.create({
+						files: ['**/*.svelte', '**/*.svelte.ts', '**/*.svelte.js'],
+						languageOptions: {
+							parserOptions: {
+								projectService: true,
+								extraFileExtensions: ['.svelte'],
+								parser: js.variables.createIdentifier('ts.parser'),
+								svelteConfig: js.variables.createIdentifier('svelteConfig')
+							}
 						}
-					}
+					});
+					eslintConfigs.push(svelteTSParserConfig);
+				} else {
+					const svelteTSParserConfig = js.object.create({
+						files: ['**/*.svelte', '**/*.svelte.js'],
+						languageOptions: {
+							parserOptions: {
+								svelteConfig: js.variables.createIdentifier('svelteConfig')
+							}
+						}
+					});
+					eslintConfigs.push(svelteTSParserConfig);
+				}
+
+				const exportExpression = js.functions.createCall({ name: 'defineConfig', args: [] });
+				if (typescript) {
+					exportExpression.arguments.push(...eslintConfigs);
+				} else {
+					const eslintArray = js.array.create();
+					eslintConfigs.map((x) => js.array.append(eslintArray, x));
+					exportExpression.arguments.push(eslintArray);
+				}
+				const { value: defaultExport } = js.exports.createDefault(ast, {
+					fallback: exportExpression
+				});
+				// if it's not the config we created, then we'll leave it alone and exit out
+				if (defaultExport !== exportExpression) {
+					log.warn('An eslint config is already defined. Skipping initialization.');
+					return false;
+				}
+
+				if (typescript) js.imports.addDefault(ast, { from: 'typescript-eslint', as: 'ts' });
+				js.imports.addDefault(ast, { from: 'globals', as: 'globals' });
+				js.imports.addNamed(ast, { from: 'eslint/config', imports: ['defineConfig'] });
+				js.imports.addDefault(ast, { from: 'eslint-plugin-svelte', as: 'svelte' });
+				js.imports.addDefault(ast, { from: '@eslint/js', as: 'js' });
+				js.imports.addNamed(ast, {
+					from: '@eslint/compat',
+					imports: ['includeIgnoreFile']
 				});
-				eslintConfigs.push(svelteTSParserConfig);
-			}
-
-			const exportExpression = js.functions.createCall({ name: 'defineConfig', args: [] });
-			if (typescript) {
-				exportExpression.arguments.push(...eslintConfigs);
-			} else {
-				const eslintArray = js.array.create();
-				eslintConfigs.map((x) => js.array.append(eslintArray, x));
-				exportExpression.arguments.push(eslintArray);
-			}
-			const { value: defaultExport } = js.exports.createDefault(ast, {
-				fallback: exportExpression
-			});
-			// if it's not the config we created, then we'll leave it alone and exit out
-			if (defaultExport !== exportExpression) {
-				log.warn('An eslint config is already defined. Skipping initialization.');
-				return content;
-			}
-
-			if (typescript) js.imports.addDefault(ast, { from: 'typescript-eslint', as: 'ts' });
-			js.imports.addDefault(ast, { from: 'globals', as: 'globals' });
-			js.imports.addNamed(ast, { from: 'eslint/config', imports: ['defineConfig'] });
-			js.imports.addDefault(ast, { from: 'eslint-plugin-svelte', as: 'svelte' });
-			js.imports.addDefault(ast, { from: '@eslint/js', as: 'js' });
-			js.imports.addNamed(ast, {
-				from: '@eslint/compat',
-				imports: ['includeIgnoreFile']
-			});
-			js.imports.addDefault(ast, { from: 'node:path', as: 'path' });
-
-			return generateCode();
-		});
-
-		sv.file(file.vscodeExtensions, (content) => {
-			const { data, generateCode } = parse.json(content);
-			json.arrayUpsert(data, 'recommendations', 'dbaeumer.vscode-eslint');
-			return generateCode();
-		});
+				js.imports.addDefault(ast, { from: 'node:path', as: 'path' });
+			})
+		);
+
+		sv.file(
+			file.vscodeExtensions,
+			transforms.json(({ data, json }) => {
+				json.arrayUpsert(data, 'recommendations', 'dbaeumer.vscode-eslint');
+			})
+		);
 
 		if (prettierInstalled) {
 			sv.file(file.eslintConfig, addEslintConfigPrettier);
diff --git a/packages/sv/src/addons/mcp.ts b/packages/sv/src/addons/mcp.ts
index 4d10915d7..548f78e6f 100644
--- a/packages/sv/src/addons/mcp.ts
+++ b/packages/sv/src/addons/mcp.ts
@@ -1,5 +1,5 @@
 import { log } from '@clack/prompts';
-import { color, parse } from '@sveltejs/sv-utils';
+import { color, transforms } from '@sveltejs/sv-utils';
 import { defineAddon, defineAddonOptions } from '../core/config.ts';
 import { getSharedFiles } from '../create/utils.ts';
 
@@ -143,44 +143,45 @@ export default defineAddon({
 				sv.file(agentPath, (content) => {
 					if (content) {
 						filesExistingAlready.push(agentPath);
-						return content;
+						return false;
 					}
 					filesAdded.push(agentPath);
 					return agentFile?.contents ?? '';
 				});
 			}
 
-			sv.file(configPath, (content) => {
-				const { data, generateCode } = parse.json(content);
-
-				if (schema) {
-					data['$schema'] = schema;
-				}
+			sv.file(
+				configPath,
+				transforms.json(({ data }) => {
+					if (schema) {
+						data['$schema'] = schema;
+					}
 
-				if (customData) {
-					for (const [key, value] of Object.entries(customData)) {
-						data[key] = value;
+					if (customData) {
+						for (const [key, value] of Object.entries(customData)) {
+							data[key] = value;
+						}
 					}
-				}
 
-				if (mcpOptions) {
-					const key = mcpOptions.serversKey ?? 'mcpServers';
-					data[key] ??= {};
-					data[key].svelte =
-						options.setup === 'local' ? getLocalConfig(mcpOptions) : getRemoteConfig(mcpOptions);
-				}
-				return generateCode();
-			});
+					if (mcpOptions) {
+						const key = mcpOptions.serversKey ?? 'mcpServers';
+						data[key] ??= {};
+						data[key].svelte =
+							options.setup === 'local' ? getLocalConfig(mcpOptions) : getRemoteConfig(mcpOptions);
+					}
+				})
+			);
 
 			if (extraFiles) {
 				for (const extra of extraFiles) {
-					sv.file(extra.path, (content) => {
-						const { data, generateCode } = parse.json(content);
-						for (const [key, value] of Object.entries(extra.data)) {
-							data[key] = value;
-						}
-						return generateCode();
-					});
+					sv.file(
+						extra.path,
+						transforms.json(({ data }) => {
+							for (const [key, value] of Object.entries(extra.data)) {
+								data[key] = value;
+							}
+						})
+					);
 				}
 			}
 		}
diff --git a/packages/sv/src/addons/mdsvex.ts b/packages/sv/src/addons/mdsvex.ts
index 79168c56f..d3f6968b5 100644
--- a/packages/sv/src/addons/mdsvex.ts
+++ b/packages/sv/src/addons/mdsvex.ts
@@ -1,4 +1,4 @@
-import { js, parse } from '@sveltejs/sv-utils';
+import { transforms } from '@sveltejs/sv-utils';
 import { defineAddon } from '../core/config.ts';
 
 export default defineAddon({
@@ -9,45 +9,44 @@ export default defineAddon({
 	run: ({ sv, file }) => {
 		sv.devDependency('mdsvex', '^0.12.6');
 
-		sv.file(file.svelteConfig, (content) => {
-			const { ast, generateCode } = parse.script(content);
+		sv.file(
+			file.svelteConfig,
+			transforms.script(({ ast, js }) => {
+				js.imports.addNamed(ast, { from: 'mdsvex', imports: ['mdsvex'] });
 
-			js.imports.addNamed(ast, { from: 'mdsvex', imports: ['mdsvex'] });
-
-			const { value: exportDefault } = js.exports.createDefault(ast, {
-				fallback: js.object.create({})
-			});
-
-			// preprocess
-			let preprocessorArray = js.object.property(exportDefault, {
-				name: 'preprocess',
-				fallback: js.array.create()
-			});
-			const isArray = preprocessorArray.type === 'ArrayExpression';
-
-			if (!isArray) {
-				const previousElement = preprocessorArray;
-				preprocessorArray = js.array.create();
-				js.array.append(preprocessorArray, previousElement);
-				js.object.overrideProperties(exportDefault, {
-					preprocess: preprocessorArray
+				const { value: exportDefault } = js.exports.createDefault(ast, {
+					fallback: js.object.create({})
 				});
-			}
-
-			const mdsvexCall = js.functions.createCall({ name: 'mdsvex', args: [] });
-			mdsvexCall.arguments.push(js.object.create({ extensions: ['.svx', '.md'] }));
-			js.array.append(preprocessorArray, mdsvexCall);
 
-			// extensions
-			const extensionsArray = js.object.property(exportDefault, {
-				name: 'extensions',
-				fallback: js.array.create()
-			});
-			js.array.append(extensionsArray, '.svelte');
-			js.array.append(extensionsArray, '.svx');
-			js.array.append(extensionsArray, '.md');
-
-			return generateCode();
-		});
+				// preprocess
+				let preprocessorArray = js.object.property(exportDefault, {
+					name: 'preprocess',
+					fallback: js.array.create()
+				});
+				const isArray = preprocessorArray.type === 'ArrayExpression';
+
+				if (!isArray) {
+					const previousElement = preprocessorArray;
+					preprocessorArray = js.array.create();
+					js.array.append(preprocessorArray, previousElement);
+					js.object.overrideProperties(exportDefault, {
+						preprocess: preprocessorArray
+					});
+				}
+
+				const mdsvexCall = js.functions.createCall({ name: 'mdsvex', args: [] });
+				mdsvexCall.arguments.push(js.object.create({ extensions: ['.svx', '.md'] }));
+				js.array.append(preprocessorArray, mdsvexCall);
+
+				// extensions
+				const extensionsArray = js.object.property(exportDefault, {
+					name: 'extensions',
+					fallback: js.array.create()
+				});
+				js.array.append(extensionsArray, '.svelte');
+				js.array.append(extensionsArray, '.svx');
+				js.array.append(extensionsArray, '.md');
+			})
+		);
 	}
 });
diff --git a/packages/sv/src/addons/paraglide.ts b/packages/sv/src/addons/paraglide.ts
index ecf953b7a..8d288183f 100644
--- a/packages/sv/src/addons/paraglide.ts
+++ b/packages/sv/src/addons/paraglide.ts
@@ -1,5 +1,5 @@
 import { log } from '@clack/prompts';
-import { color, html, js, parse, svelte, type SvelteAst, text } from '@sveltejs/sv-utils';
+import { color, type SvelteAst, transforms } from '@sveltejs/sv-utils';
 import { defineAddon, defineAddonOptions } from '../core/config.ts';
 import { addToDemoPage } from './common.ts';
 
@@ -59,205 +59,200 @@ export default defineAddon({
 		sv.devDependency('@inlang/paraglide-js', '^2.10.0');
 
 		// add the vite plugin
-		sv.file(file.viteConfig, (content) => {
-			const { ast, generateCode } = parse.script(content);
-
-			const vitePluginName = 'paraglideVitePlugin';
-			js.imports.addNamed(ast, { imports: [vitePluginName], from: '@inlang/paraglide-js' });
-			js.vite.addPlugin(ast, {
-				code: `${vitePluginName}({
+		sv.file(
+			file.viteConfig,
+			transforms.script(({ ast, js }) => {
+				const vitePluginName = 'paraglideVitePlugin';
+				js.imports.addNamed(ast, { imports: [vitePluginName], from: '@inlang/paraglide-js' });
+				js.vite.addPlugin(ast, {
+					code: `${vitePluginName}({
 					project: './project.inlang',
 					outdir: './${paraglideOutDir}'
 				})`
-			});
-
-			return generateCode();
-		});
+				});
+			})
+		);
 
 		// reroute hook
-		sv.file(`src/hooks.${language}`, (content) => {
-			const { ast, generateCode, comments } = parse.script(content);
+		sv.file(
+			`src/hooks.${language}`,
+			transforms.script(({ ast, comments, js }) => {
+				js.imports.addNamed(ast, {
+					from: '$lib/paraglide/runtime',
+					imports: ['deLocalizeUrl']
+				});
 
-			js.imports.addNamed(ast, {
-				from: '$lib/paraglide/runtime',
-				imports: ['deLocalizeUrl']
-			});
+				const expression = js.common.parseExpression(
+					'(request) => deLocalizeUrl(request.url).pathname'
+				);
+				const rerouteIdentifier = js.variables.declaration(ast, {
+					kind: 'const',
+					name: `reroute${language === 'ts' ? ': Reroute' : ''}`,
+					value: expression
+				});
 
-			const expression = js.common.parseExpression(
-				'(request) => deLocalizeUrl(request.url).pathname'
-			);
+				const existingExport = js.exports.createNamed(ast, {
+					name: 'reroute',
+					fallback: rerouteIdentifier
+				});
+				if (existingExport.declaration !== rerouteIdentifier) {
+					log.warn('Adding the reroute hook automatically failed. Add it manually');
+				}
 
-			const rerouteIdentifier = js.variables.declaration(ast, {
-				kind: 'const',
-				name: `reroute${language === 'ts' ? ': Reroute' : ''}`,
-				value: expression
-			});
-
-			const existingExport = js.exports.createNamed(ast, {
-				name: 'reroute',
-				fallback: rerouteIdentifier
-			});
-			if (existingExport.declaration !== rerouteIdentifier) {
-				log.warn('Adding the reroute hook automatically failed. Add it manually');
-			}
+				if (language === 'ts') {
+					js.imports.addNamed(ast, {
+						from: '@sveltejs/kit',
+						imports: ['Reroute'],
+						isType: true
+					});
+				} else {
+					js.common.addJsDocTypeComment(existingExport, comments, {
+						type: "import('@sveltejs/kit').Reroute"
+					});
+				}
+			})
+		);
 
-			if (language === 'ts') {
+		// handle hook
+		sv.file(
+			`src/hooks.server.${language}`,
+			transforms.script(({ ast, comments, js }) => {
 				js.imports.addNamed(ast, {
-					from: '@sveltejs/kit',
-					imports: ['Reroute'],
-					isType: true
+					from: '$lib/paraglide/server',
+					imports: ['paraglideMiddleware']
 				});
-			} else {
-				js.common.addJsDocTypeComment(existingExport, comments, {
-					type: "import('@sveltejs/kit').Reroute"
+				js.imports.addNamed(ast, {
+					from: '$lib/paraglide/runtime',
+					imports: ['getTextDirection']
 				});
-			}
-
-			return generateCode();
-		});
 
-		// handle hook
-		sv.file(`src/hooks.server.${language}`, (content) => {
-			const { ast, generateCode, comments } = parse.script(content);
-			js.imports.addNamed(ast, {
-				from: '$lib/paraglide/server',
-				imports: ['paraglideMiddleware']
-			});
-			js.imports.addNamed(ast, {
-				from: '$lib/paraglide/runtime',
-				imports: ['getTextDirection']
-			});
-
-			const hookHandleContent = `({ event, resolve }) => paraglideMiddleware(event.request, ({ request, locale }) => {
+				const hookHandleContent = `({ event, resolve }) => paraglideMiddleware(event.request, ({ request, locale }) => {
 		event.request = request;
 		return resolve(event, {
 			transformPageChunk: ({ html }) => html.replace('%paraglide.lang%', locale).replace('%paraglide.dir%', getTextDirection(locale))
 		});
 	});`;
-			js.kit.addHooksHandle(ast, {
-				language,
-				newHandleName: 'handleParaglide',
-				handleContent: hookHandleContent,
-				comments
-			});
-
-			return generateCode();
-		});
+				js.kit.addHooksHandle(ast, {
+					language,
+					newHandleName: 'handleParaglide',
+					handleContent: hookHandleContent,
+					comments
+				});
+			})
+		);
 
 		// add the lang and dir attributes placeholder to app.html
-		sv.file('src/app.html', (content) => {
-			const { ast, generateCode } = parse.html(content);
-
-			const htmlNode = ast.nodes.find(
-				(child): child is SvelteAst.RegularElement =>
-					child.type === 'RegularElement' && child.name === 'html'
-			);
-			if (!htmlNode) {
-				log.warn(
-					"Could not find <html> node in app.html. You'll need to add the language placeholder manually"
+		sv.file(
+			'src/app.html',
+			transforms.html(({ ast, html }) => {
+				const htmlNode = ast.nodes.find(
+					(child): child is SvelteAst.RegularElement =>
+						child.type === 'RegularElement' && child.name === 'html'
 				);
-				return generateCode();
-			}
-			html.addAttribute(htmlNode, 'lang', '%paraglide.lang%');
-			html.addAttribute(htmlNode, 'dir', '%paraglide.dir%');
-
-			return generateCode();
-		});
-
-		sv.file(file.gitignore, (content) => {
-			if (!content) return content;
-
-			content = text.upsert(content, paraglideOutDir, { comment: 'Paraglide' });
-			content = text.upsert(content, 'project.inlang/cache/');
-
-			return content;
-		});
-
-		sv.file('project.inlang/settings.json', (content) => {
-			if (content) return content;
-
-			const { data, generateCode } = parse.json(content);
-
-			for (const key in DEFAULT_INLANG_PROJECT) {
-				data[key] = DEFAULT_INLANG_PROJECT[key as keyof typeof DEFAULT_INLANG_PROJECT];
-			}
-			const { validLanguageTags } = parseLanguageTagInput(options.languageTags);
-			const baseLocale = validLanguageTags[0];
-
-			data.baseLocale = baseLocale;
-			data.locales = validLanguageTags;
+				if (!htmlNode) {
+					log.warn(
+						"Could not find <html> node in app.html. You'll need to add the language placeholder manually"
+					);
+					return false;
+				}
+				html.addAttribute(htmlNode, 'lang', '%paraglide.lang%');
+				html.addAttribute(htmlNode, 'dir', '%paraglide.dir%');
+			})
+		);
+
+		sv.file(
+			file.gitignore,
+			transforms.text(({ content, text }) => {
+				if (!content) return false;
+
+				content = text.upsert(content, paraglideOutDir, { comment: 'Paraglide' });
+				content = text.upsert(content, 'project.inlang/cache/');
+
+				return content;
+			})
+		);
+
+		sv.file(
+			'project.inlang/settings.json',
+			transforms.json(({ data }) => {
+				if (Object.keys(data).length > 0) return false;
+
+				for (const key in DEFAULT_INLANG_PROJECT) {
+					data[key] = DEFAULT_INLANG_PROJECT[key as keyof typeof DEFAULT_INLANG_PROJECT];
+				}
+				const { validLanguageTags } = parseLanguageTagInput(options.languageTags);
+				const baseLocale = validLanguageTags[0];
 
-			return generateCode();
-		});
+				data.baseLocale = baseLocale;
+				data.locales = validLanguageTags;
+			})
+		);
 
-		sv.file(`${directory.kitRoutes}/+layout.svelte`, (content) => {
-			const { ast, generateCode } = parse.svelte(content);
-			svelte.ensureScript(ast, { language });
-			js.imports.addNamed(ast.instance.content, {
-				imports: ['locales', 'localizeHref'],
-				from: '$lib/paraglide/runtime'
-			});
-			js.imports.addNamed(ast.instance.content, { imports: ['page'], from: '$app/state' });
-			svelte.addFragment(
-				ast,
-				`<div style="display:none">
+		sv.file(
+			`${directory.kitRoutes}/+layout.svelte`,
+			transforms.svelteScript({ language }, ({ ast, svelte, js }) => {
+				js.imports.addNamed(ast.instance.content, {
+					imports: ['locales', 'localizeHref'],
+					from: '$lib/paraglide/runtime'
+				});
+				js.imports.addNamed(ast.instance.content, { imports: ['page'], from: '$app/state' });
+				svelte.addFragment(
+					ast,
+					`<div style="display:none">
 	{#each locales as locale}
 		<a href={localizeHref(page.url.pathname, { locale })}>{locale}</a>
 	{/each}
 </div>`
-			);
-			return generateCode();
-		});
+				);
+			})
+		);
 
 		if (options.demo) {
-			sv.file(`${directory.kitRoutes}/demo/+page.svelte`, (content) => {
-				return addToDemoPage(content, 'paraglide', language);
-			});
+			sv.file(`${directory.kitRoutes}/demo/+page.svelte`, addToDemoPage('paraglide', language));
 
 			// add usage example
-			sv.file(`${directory.kitRoutes}/demo/paraglide/+page.svelte`, (content) => {
-				const { ast, generateCode } = parse.svelte(content);
-				svelte.ensureScript(ast, { language });
-
-				js.imports.addNamed(ast.instance.content, {
-					imports: { m: 'm' },
-					from: '$lib/paraglide/messages.js'
-				});
-				js.imports.addNamed(ast.instance.content, {
-					imports: {
-						setLocale: 'setLocale'
-					},
-					from: '$lib/paraglide/runtime'
-				});
-
-				// add localized message
-				let templateCode = "<h1>{m.hello_world({ name: 'SvelteKit User' })}</h1>";
-
-				// add links to other localized pages, the first one is the default
-				// language, thus it does not require any localized route
-				const { validLanguageTags } = parseLanguageTagInput(options.languageTags);
-				const links = validLanguageTags
-					.map((x) => `<button onclick={() => setLocale('${x}')}>${x}</button>`)
-					.join('');
-				templateCode += `<div>${links}</div>`;
-
-				templateCode +=
-					'<p>If you use VSCode, install the <a href="https://marketplace.visualstudio.com/items?itemName=inlang.vs-code-extension" target="_blank">Sherlock i18n extension</a> for a better i18n experience.</p>';
-
-				svelte.addFragment(ast, templateCode);
-
-				return generateCode();
-			});
+			sv.file(
+				`${directory.kitRoutes}/demo/paraglide/+page.svelte`,
+				transforms.svelteScript({ language }, ({ ast, svelte, js }) => {
+					js.imports.addNamed(ast.instance.content, {
+						imports: { m: 'm' },
+						from: '$lib/paraglide/messages.js'
+					});
+					js.imports.addNamed(ast.instance.content, {
+						imports: {
+							setLocale: 'setLocale'
+						},
+						from: '$lib/paraglide/runtime'
+					});
+
+					// add localized message
+					let templateCode = "<h1>{m.hello_world({ name: 'SvelteKit User' })}</h1>";
+
+					// add links to other localized pages, the first one is the default
+					// language, thus it does not require any localized route
+					const { validLanguageTags } = parseLanguageTagInput(options.languageTags);
+					const links = validLanguageTags
+						.map((x) => `<button onclick={() => setLocale('${x}')}>${x}</button>`)
+						.join('');
+					templateCode += `<div>${links}</div>`;
+
+					templateCode +=
+						'<p>If you use VSCode, install the <a href="https://marketplace.visualstudio.com/items?itemName=inlang.vs-code-extension" target="_blank">Sherlock i18n extension</a> for a better i18n experience.</p>';
+
+					svelte.addFragment(ast, templateCode);
+				})
+			);
 		}
 
 		const { validLanguageTags } = parseLanguageTagInput(options.languageTags);
 		for (const languageTag of validLanguageTags) {
-			sv.file(`messages/${languageTag}.json`, (content) => {
-				const { data, generateCode } = parse.json(content);
-				data['$schema'] = 'https://inlang.com/schema/inlang-message-format';
-				data.hello_world = `Hello, {name} from ${languageTag}!`;
-				return generateCode();
-			});
+			sv.file(
+				`messages/${languageTag}.json`,
+				transforms.json(({ data }) => {
+					data['$schema'] = 'https://inlang.com/schema/inlang-message-format';
+					data.hello_world = `Hello, {name} from ${languageTag}!`;
+				})
+			);
 		}
 	},
 
diff --git a/packages/sv/src/addons/playwright.ts b/packages/sv/src/addons/playwright.ts
index 9cda97cfc..b5f0015c6 100644
--- a/packages/sv/src/addons/playwright.ts
+++ b/packages/sv/src/addons/playwright.ts
@@ -1,5 +1,5 @@
 import { log } from '@clack/prompts';
-import { color, dedent, js, parse, json, text } from '@sveltejs/sv-utils';
+import { color, dedent, transforms } from '@sveltejs/sv-utils';
 import { defineAddon } from '../core/config.ts';
 import { addToDemoPage } from './common.ts';
 
@@ -11,76 +11,83 @@ export default defineAddon({
 	run: ({ sv, language, file, isKit, directory }) => {
 		sv.devDependency('@playwright/test', '^1.58.2');
 
-		sv.file(file.package, (content) => {
-			const { data, generateCode } = parse.json(content);
-
-			json.packageScriptsUpsert(data, 'test:e2e', 'playwright test');
-			json.packageScriptsUpsert(data, 'test', 'npm run test:e2e');
-
-			return generateCode();
-		});
-
-		sv.file(file.gitignore, (content) => {
-			if (!content) return content;
-			return text.upsert(content, 'test-results', { comment: 'Playwright' });
-		});
+		sv.file(
+			file.package,
+			transforms.json(({ data, json }) => {
+				json.packageScriptsUpsert(data, 'test:e2e', 'playwright test');
+				json.packageScriptsUpsert(data, 'test', 'npm run test:e2e');
+			})
+		);
+
+		sv.file(
+			file.gitignore,
+			transforms.text(({ content, text }) => {
+				if (!content) return false;
+				return text.upsert(content, 'test-results', { comment: 'Playwright' });
+			})
+		);
 
 		const testDir = isKit ? `${directory.kitRoutes}/demo/playwright` : directory.src;
 		const testRoute = isKit ? '/demo/playwright' : '/';
 
 		if (isKit) {
-			sv.file(`${directory.kitRoutes}/demo/+page.svelte`, (content) => {
-				return addToDemoPage(content, 'playwright', language);
-			});
+			sv.file(`${directory.kitRoutes}/demo/+page.svelte`, addToDemoPage('playwright', language));
 
-			sv.file(`${testDir}/+page.svelte`, (content) => {
-				if (content) return content;
+			sv.file(
+				`${testDir}/+page.svelte`,
+				transforms.text(({ content }) => {
+					if (content) return false;
 
-				return dedent`
-					<h1>Playwright e2e test demo</h1>
+					return dedent`
+						<h1>Playwright e2e test demo</h1>
 					`;
-			});
+				})
+			);
 		}
 
-		sv.file(`${testDir}/${isKit ? 'page' : 'app'}.svelte.e2e.${language}`, (content) => {
-			if (content) return content;
+		sv.file(
+			`${testDir}/${isKit ? 'page' : 'app'}.svelte.e2e.${language}`,
+			transforms.text(({ content }) => {
+				if (content) return false;
 
-			return dedent`
-				import { expect, test } from '@playwright/test';
+				return dedent`
+					import { expect, test } from '@playwright/test';
 
-				test('has expected h1', async ({ page }) => {
-					await page.goto('${testRoute}');
-					await expect(page.locator('h1')).toBeVisible();
-				});
+					test('has expected h1', async ({ page }) => {
+						await page.goto('${testRoute}');
+						await expect(page.locator('h1')).toBeVisible();
+					});
 				`;
-		});
-
-		sv.file(`playwright.config.${language}`, (content) => {
-			const { ast, generateCode } = parse.script(content);
-			const defineConfig = js.common.parseExpression('defineConfig({})');
-			const { value: defaultExport } = js.exports.createDefault(ast, { fallback: defineConfig });
-
-			const config = {
-				webServer: {
-					command: 'npm run build && npm run preview',
-					port: 4173
-				},
-				testMatch: '**/*.e2e.{ts,js}'
-			};
-
-			if (
-				defaultExport.type === 'CallExpression' &&
-				defaultExport.arguments[0]?.type === 'ObjectExpression'
-			) {
-				js.imports.addNamed(ast, { imports: ['defineConfig'], from: '@playwright/test' });
-				js.object.overrideProperties(defaultExport.arguments[0], config);
-			} else if (defaultExport.type === 'ObjectExpression') {
-				js.object.overrideProperties(defaultExport, config);
-			} else {
-				log.warn('Unexpected playwright config for playwright add-on. Could not update.');
-			}
-			return generateCode();
-		});
+			})
+		);
+
+		sv.file(
+			`playwright.config.${language}`,
+			transforms.script(({ ast, js }) => {
+				const defineConfig = js.common.parseExpression('defineConfig({})');
+				const { value: defaultExport } = js.exports.createDefault(ast, { fallback: defineConfig });
+
+				const config = {
+					webServer: {
+						command: 'npm run build && npm run preview',
+						port: 4173
+					},
+					testMatch: '**/*.e2e.{ts,js}'
+				};
+
+				if (
+					defaultExport.type === 'CallExpression' &&
+					defaultExport.arguments[0]?.type === 'ObjectExpression'
+				) {
+					js.imports.addNamed(ast, { imports: ['defineConfig'], from: '@playwright/test' });
+					js.object.overrideProperties(defaultExport.arguments[0], config);
+				} else if (defaultExport.type === 'ObjectExpression') {
+					js.object.overrideProperties(defaultExport, config);
+				} else {
+					log.warn('Unexpected playwright config for playwright add-on. Could not update.');
+				}
+			})
+		);
 	},
 
 	nextSteps: ({ isKit }) => {
diff --git a/packages/sv/src/addons/prettier.ts b/packages/sv/src/addons/prettier.ts
index 6d1af4a2a..eea8f1252 100644
--- a/packages/sv/src/addons/prettier.ts
+++ b/packages/sv/src/addons/prettier.ts
@@ -1,5 +1,5 @@
 import { log } from '@clack/prompts';
-import { color, dedent, parse, json } from '@sveltejs/sv-utils';
+import { color, dedent, transforms } from '@sveltejs/sv-utils';
 import { defineAddon } from '../core/config.ts';
 import { addEslintConfigPrettier } from './common.ts';
 
@@ -15,73 +15,78 @@ export default defineAddon({
 		sv.devDependency('prettier', '^3.8.1');
 		sv.devDependency('prettier-plugin-svelte', '^3.4.1');
 
-		sv.file(file.prettierignore, (content) => {
-			if (content) return content;
-			return dedent`
-				# Package Managers
-				package-lock.json
-				pnpm-lock.yaml
-				yarn.lock
-				bun.lock
-				bun.lockb
-
-				# Miscellaneous
-				/static/
-			`;
-		});
-
-		sv.file(file.prettierrc, (content) => {
-			let data, generateCode;
-			try {
-				({ data, generateCode } = parse.json(content));
-			} catch {
-				log.warn(
-					`A ${color.warning('.prettierrc')} config already exists and cannot be parsed as JSON. Skipping initialization.`
-				);
-				return content;
-			}
-			if (Object.keys(data).length === 0) {
-				// we'll only set these defaults if there is no pre-existing config
-				data.useTabs = true;
-				data.singleQuote = true;
-				data.trailingComma = 'none';
-				data.printWidth = 100;
-			}
-
-			json.arrayUpsert(data, 'plugins', 'prettier-plugin-svelte');
-
-			if (tailwindcssInstalled) {
-				json.arrayUpsert(data, 'plugins', 'prettier-plugin-tailwindcss');
-				data.tailwindStylesheet ??= file.getRelative({ to: file.stylesheet });
-			}
-
-			data.overrides ??= [];
-			const overrides: Array<{ files: string | string[]; options?: { parser?: string } }> =
-				data.overrides;
-			const override = overrides.find((o) => o?.options?.parser === 'svelte');
-			if (!override) {
-				overrides.push({ files: '*.svelte', options: { parser: 'svelte' } });
-			}
-			return generateCode();
-		});
+		sv.file(
+			file.prettierignore,
+			transforms.text(({ content }) => {
+				if (content) return false;
+				return dedent`
+					# Package Managers
+					package-lock.json
+					pnpm-lock.yaml
+					yarn.lock
+					bun.lock
+					bun.lockb
+
+					# Miscellaneous
+					/static/
+				`;
+			})
+		);
+
+		sv.file(
+			file.prettierrc,
+			transforms.json(
+				({ data, json }) => {
+					if (Object.keys(data).length === 0) {
+						// we'll only set these defaults if there is no pre-existing config
+						data.useTabs = true;
+						data.singleQuote = true;
+						data.trailingComma = 'none';
+						data.printWidth = 100;
+					}
+
+					json.arrayUpsert(data, 'plugins', 'prettier-plugin-svelte');
+
+					if (tailwindcssInstalled) {
+						json.arrayUpsert(data, 'plugins', 'prettier-plugin-tailwindcss');
+						data.tailwindStylesheet ??= file.getRelative({ to: file.stylesheet });
+					}
+
+					data.overrides ??= [];
+					const overrides: Array<{ files: string | string[]; options?: { parser?: string } }> =
+						data.overrides;
+					const override = overrides.find((o) => o?.options?.parser === 'svelte');
+					if (!override) {
+						overrides.push({ files: '*.svelte', options: { parser: 'svelte' } });
+					}
+				},
+				{
+					onError: () => {
+						log.warn(
+							`A ${color.warning('.prettierrc')} config already exists and cannot be parsed as JSON. Skipping initialization.`
+						);
+					}
+				}
+			)
+		);
 
 		const eslintVersion = dependencyVersion('eslint');
 		const eslintInstalled = hasEslint(eslintVersion);
 
-		sv.file(file.package, (content) => {
-			const { data, generateCode } = parse.json(content);
-
-			json.packageScriptsUpsert(data, 'lint', 'prettier --check .', { mode: 'prepend' });
-			json.packageScriptsUpsert(data, 'format', 'prettier --write .');
-
-			return generateCode();
-		});
-
-		sv.file(file.vscodeExtensions, (content) => {
-			const { data, generateCode } = parse.json(content);
-			json.arrayUpsert(data, 'recommendations', 'esbenp.prettier-vscode');
-			return generateCode();
-		});
+		sv.file(
+			file.package,
+			transforms.json(({ data, json }) => {
+				json.packageScriptsUpsert(data, 'lint', 'prettier --check .', { mode: 'prepend' });
+				json.packageScriptsUpsert(data, 'format', 'prettier --write .');
+			})
+		);
+
+		sv.file(
+			file.vscodeExtensions,
+			transforms.json(({ data, json }) => {
+				json.arrayUpsert(data, 'recommendations', 'esbenp.prettier-vscode');
+			})
+		);
 
 		if (eslintVersion?.startsWith(SUPPORTED_ESLINT_VERSION) === false) {
 			log.warn(
diff --git a/packages/sv/src/addons/sveltekit-adapter.ts b/packages/sv/src/addons/sveltekit-adapter.ts
index 192cdf892..e4cd55a9e 100644
--- a/packages/sv/src/addons/sveltekit-adapter.ts
+++ b/packages/sv/src/addons/sveltekit-adapter.ts
@@ -1,15 +1,13 @@
 import {
 	color,
-	js,
 	resolveCommand,
-	json,
-	sanitizeName,
 	text,
-	parse,
-	fileExists
+	transforms,
+	fileExists,
+	getPackageJson,
+	sanitizeName,
+	commonFilePaths
 } from '@sveltejs/sv-utils';
-import { readFileSync } from 'node:fs';
-import { join } from 'node:path';
 import { defineAddon, defineAddonOptions } from '../core/config.ts';
 
 const adapters = [
@@ -53,81 +51,82 @@ export default defineAddon({
 		const adapter = adapters.find((a) => a.id === options.adapter)!;
 
 		// removes previously installed adapters
-		sv.file(file.package, (content) => {
-			const { data, generateCode } = parse.json(content);
-			const devDeps = data['devDependencies'];
-
-			for (const pkg of Object.keys(devDeps)) {
-				if (pkg.startsWith('@sveltejs/adapter-')) {
-					delete devDeps[pkg];
+		sv.file(
+			file.package,
+			transforms.json(({ data }) => {
+				const devDeps = data['devDependencies'];
+
+				for (const pkg of Object.keys(devDeps)) {
+					if (pkg.startsWith('@sveltejs/adapter-')) {
+						delete devDeps[pkg];
+					}
 				}
-			}
 
-			// in sk 3, we will keep "preview": "vite preview" like any other adapter
-			if (options.adapter === 'cloudflare') {
-				const preview =
-					options.cfTarget === 'workers'
-						? 'wrangler dev .svelte-kit/cloudflare/_worker.js --port 4173'
-						: 'wrangler pages dev .svelte-kit/cloudflare --port 4173';
-				data.scripts.preview = preview;
-			}
-
-			return generateCode();
-		});
+				// in sk 3, we will keep "preview": "vite preview" like any other adapter
+				if (options.adapter === 'cloudflare') {
+					const preview =
+						options.cfTarget === 'workers'
+							? 'wrangler dev .svelte-kit/cloudflare/_worker.js --port 4173'
+							: 'wrangler pages dev .svelte-kit/cloudflare --port 4173';
+					data.scripts.preview = preview;
+				}
+			})
+		);
 
 		sv.devDependency(adapter.package, adapter.version);
 
-		sv.file(file.svelteConfig, (content) => {
-			const { ast, comments, generateCode } = parse.script(content);
+		sv.file(
+			file.svelteConfig,
+			transforms.script(({ ast, comments, js }) => {
+				// finds any existing adapter's import declaration
+				const imports = ast.body.filter((n) => n.type === 'ImportDeclaration');
+				const adapterImports = imports.find(
+					(importDecl) =>
+						typeof importDecl.source.value === 'string' &&
+						importDecl.source.value.startsWith('@sveltejs/adapter-') &&
+						importDecl.importKind === 'value'
+				);
 
-			// finds any existing adapter's import declaration
-			const importDecls = ast.body.filter((n) => n.type === 'ImportDeclaration');
-			const adapterImportDecl = importDecls.find(
-				(importDecl) =>
-					typeof importDecl.source.value === 'string' &&
-					importDecl.source.value.startsWith('@sveltejs/adapter-') &&
-					importDecl.importKind === 'value'
-			);
+				let adapterName = 'adapter';
+				if (adapterImports) {
+					// replaces the import's source with the new adapter
+					adapterImports.source.value = adapter.package;
+					// reset raw value, so that the string is re-generated
+					adapterImports.source.raw = undefined;
 
-			let adapterName = 'adapter';
-			if (adapterImportDecl) {
-				// replaces the import's source with the new adapter
-				adapterImportDecl.source.value = adapter.package;
-				// reset raw value, so that the string is re-generated
-				adapterImportDecl.source.raw = undefined;
-
-				adapterName = adapterImportDecl.specifiers?.find((s) => s.type === 'ImportDefaultSpecifier')
-					?.local?.name as string;
-			} else {
-				js.imports.addDefault(ast, { from: adapter.package, as: adapterName });
-			}
+					const defaultSpecifier = adapterImports.specifiers?.find(
+						(s) => s.type === 'ImportDefaultSpecifier'
+					);
+					adapterName = defaultSpecifier!.local.name;
+				} else {
+					js.imports.addDefault(ast, { from: adapter.package, as: adapterName });
+				}
 
-			const { value: config } = js.exports.createDefault(ast, { fallback: js.object.create({}) });
+				const { value: config } = js.exports.createDefault(ast, { fallback: js.object.create({}) });
 
-			// override the adapter property
-			js.object.overrideProperties(config, {
-				kit: {
-					adapter: js.functions.createCall({ name: adapterName, args: [], useIdentifiers: true })
-				}
-			});
-
-			// reset the comment for non-auto adapters
-			if (adapter.package !== '@sveltejs/adapter-auto') {
-				const fallback = js.object.create({});
-				const cfgKitValue = js.object.property(config, { name: 'kit', fallback });
-
-				// removes any existing adapter auto comments
-				comments.remove(
-					(c) =>
-						c.loc &&
-						cfgKitValue.loc &&
-						c.loc.start.line >= cfgKitValue.loc.start.line &&
-						c.loc.end.line <= cfgKitValue.loc.end.line
-				);
-			}
+				// override the adapter property
+				js.object.overrideProperties(config, {
+					kit: {
+						adapter: js.functions.createCall({ name: adapterName, args: [], useIdentifiers: true })
+					}
+				});
 
-			return generateCode();
-		});
+				// reset the comment for non-auto adapters
+				if (adapter.package !== '@sveltejs/adapter-auto') {
+					const fallback = js.object.create({});
+					const cfgKitValue = js.object.property(config, { name: 'kit', fallback });
+
+					// removes any existing adapter auto comments
+					comments.remove(
+						(c) =>
+							c.loc &&
+							cfgKitValue.loc &&
+							c.loc.start.line >= cfgKitValue.loc.start.line &&
+							c.loc.end.line <= cfgKitValue.loc.end.line
+					);
+				}
+			})
+		);
 
 		if (adapter.package === '@sveltejs/adapter-cloudflare') {
 			sv.devDependency('wrangler', '^4.63.0');
@@ -135,16 +134,14 @@ export default defineAddon({
 			// default to jsonc
 			const ext = fileExists(cwd, 'wrangler.toml') ? 'toml' : 'jsonc';
 
-			// Setup Cloudlfare workers/pages config
-			sv.file(`wrangler.${ext}`, (content) => {
-				const { data, generateCode } = ext === 'jsonc' ? parse.json(content) : parse.toml(content);
-
+			// Setup Cloudflare workers/pages config
+			const applyWranglerConfig = (data: Record<string, any>) => {
 				if (ext === 'jsonc') {
 					data.$schema ??= './node_modules/wrangler/config-schema.json';
 				}
 
 				if (!data.name) {
-					const pkg = parse.json(readFileSync(join(cwd, file.package), 'utf-8'));
+					const pkg = getPackageJson(cwd);
 					data.name = sanitizeName(pkg.data.name, 'wrangler');
 				}
 
@@ -172,61 +169,66 @@ export default defineAddon({
 						data.pages_build_output_dir = '.svelte-kit/cloudflare';
 						break;
 				}
+			};
 
-				return generateCode();
-			});
+			sv.file(
+				`wrangler.${ext}`,
+				ext === 'toml'
+					? transforms.toml(({ data }) => applyWranglerConfig(data))
+					: transforms.json(({ data }) => applyWranglerConfig(data))
+			);
 
-			const jsconfig = fileExists(cwd, 'jsconfig.json');
+			const jsconfig = fileExists(cwd, commonFilePaths.jsconfig);
 			const typeChecked = language === 'ts' || jsconfig;
 
 			if (typeChecked) {
-				sv.file(file.gitignore, (content) => {
-					if (content.length === 0) return content;
-					return text.upsert(content, '/worker-configuration.d.ts', {
-						comment: 'Cloudflare Types'
-					});
-				});
+				sv.file(
+					file.gitignore,
+					transforms.text(({ content }) => {
+						if (content.length === 0) return false;
+						return text.upsert(content, '/worker-configuration.d.ts', {
+							comment: 'Cloudflare Types'
+						});
+					})
+				);
 
 				// Setup wrangler types command
-				sv.file(file.package, (content) => {
-					const { data, generateCode } = parse.json(content);
-
-					json.packageScriptsUpsert(data, 'gen', 'wrangler types');
-
-					return generateCode();
-				});
+				sv.file(
+					file.package,
+					transforms.json(({ data, json }) => {
+						json.packageScriptsUpsert(data, 'gen', 'wrangler types');
+					})
+				);
 
 				// Add Cloudflare generated types to tsconfig
-				sv.file(`${jsconfig ? 'jsconfig' : 'tsconfig'}.json`, (content) => {
-					const { data, generateCode } = parse.json(content);
-
-					data.compilerOptions ??= {};
-					data.compilerOptions.types ??= [];
-					data.compilerOptions.types.push('./worker-configuration.d.ts');
-
-					return generateCode();
-				});
-
-				sv.file('src/app.d.ts', (content) => {
-					const { ast, comments, generateCode } = parse.script(content);
-
-					const platform = js.kit.addGlobalAppInterface(ast, { name: 'Platform' });
-					if (!platform) {
-						throw new Error('Failed detecting `platform` interface in `src/app.d.ts`');
-					}
-
-					// remove the commented out placeholder since we're adding the real one
-					comments.remove((c) => c.type === 'Line' && c.value.trim() === 'interface Platform {}');
-
-					platform.body.body.push(
-						js.common.createTypeProperty('env', 'Env'),
-						js.common.createTypeProperty('ctx', 'ExecutionContext'),
-						js.common.createTypeProperty('caches', 'CacheStorage'),
-						js.common.createTypeProperty('cf', 'IncomingRequestCfProperties', true)
-					);
+				sv.file(
+					jsconfig ? commonFilePaths.jsconfig : commonFilePaths.tsconfig,
+					transforms.json(({ data }) => {
+						data.compilerOptions ??= {};
+						data.compilerOptions.types ??= [];
+						data.compilerOptions.types.push('./worker-configuration.d.ts');
+					})
+				);
 
-					return generateCode();
-				});
+				sv.file(
+					'src/app.d.ts',
+					transforms.script(({ ast, comments, js }) => {
+						const platform = js.kit.addGlobalAppInterface(ast, { name: 'Platform' });
+						if (!platform) {
+							throw new Error('Failed detecting `platform` interface in `src/app.d.ts`');
+						}
+
+						// remove the commented out placeholder since we're adding the real one
+						comments.remove((c) => c.type === 'Line' && c.value.trim() === 'interface Platform {}');
+
+						platform.body.body.push(
+							js.common.createTypeProperty('env', 'Env'),
+							js.common.createTypeProperty('ctx', 'ExecutionContext'),
+							js.common.createTypeProperty('caches', 'CacheStorage'),
+							js.common.createTypeProperty('cf', 'IncomingRequestCfProperties', true)
+						);
+					})
+				);
 			}
 		}
 	},
diff --git a/packages/sv/src/addons/tailwindcss.ts b/packages/sv/src/addons/tailwindcss.ts
index c14820d76..5dd26ce2c 100644
--- a/packages/sv/src/addons/tailwindcss.ts
+++ b/packages/sv/src/addons/tailwindcss.ts
@@ -1,4 +1,4 @@
-import { css, js, parse, svelte, json } from '@sveltejs/sv-utils';
+import { transforms } from '@sveltejs/sv-utils';
 import { defineAddon, defineAddonOptions } from '../core/config.ts';
 
 const plugins = [
@@ -46,94 +46,88 @@ export default defineAddon({
 		}
 
 		// add the vite plugin
-		sv.file(file.viteConfig, (content) => {
-			const { ast, generateCode } = parse.script(content);
-
-			const vitePluginName = 'tailwindcss';
-			js.imports.addDefault(ast, { as: vitePluginName, from: '@tailwindcss/vite' });
-			js.vite.addPlugin(ast, { code: `${vitePluginName}()`, mode: 'prepend' });
-
-			return generateCode();
-		});
-
-		sv.file(file.stylesheet, (content) => {
-			const { ast, generateCode } = parse.css(content);
-
-			// since we are prepending all the `AtRule` let's add them in reverse order,
-			// so they appear in the expected order in the final file
-
-			for (const plugin of plugins) {
-				if (!options.plugins.includes(plugin.id)) continue;
+		sv.file(
+			file.viteConfig,
+			transforms.script(({ ast, js }) => {
+				const vitePluginName = 'tailwindcss';
+				js.imports.addDefault(ast, { as: vitePluginName, from: '@tailwindcss/vite' });
+				js.vite.addPlugin(ast, { code: `${vitePluginName}()`, mode: 'prepend' });
+			})
+		);
+
+		sv.file(
+			file.stylesheet,
+			transforms.css(({ ast, css }) => {
+				// since we are prepending all the `AtRule` let's add them in reverse order,
+				// so they appear in the expected order in the final file
+
+				for (const plugin of plugins) {
+					if (!options.plugins.includes(plugin.id)) continue;
+
+					css.addAtRule(ast, {
+						name: 'plugin',
+						params: `'${plugin.package}'`,
+						append: false
+					});
+				}
 
 				css.addAtRule(ast, {
-					name: 'plugin',
-					params: `'${plugin.package}'`,
+					name: 'import',
+					params: `'tailwindcss'`,
 					append: false
 				});
-			}
-
-			css.addAtRule(ast, {
-				name: 'import',
-				params: `'tailwindcss'`,
-				append: false
-			});
-
-			return generateCode();
-		});
+			})
+		);
 
-		if (!isKit) {
-			const appSvelte = `${directory.src}/App.svelte`;
-			const stylesheetRelative = file.getRelative({ from: appSvelte, to: file.stylesheet });
-			sv.file(appSvelte, (content) => {
-				const { ast, generateCode } = parse.svelte(content);
-				svelte.ensureScript(ast, { language });
-				js.imports.addEmpty(ast.instance.content, { from: stylesheetRelative });
-				return generateCode();
-			});
-		} else {
+		if (isKit) {
 			const layoutSvelte = `${directory.kitRoutes}/+layout.svelte`;
 			const stylesheetRelative = file.getRelative({ from: layoutSvelte, to: file.stylesheet });
-			sv.file(layoutSvelte, (content) => {
-				const { ast, generateCode } = parse.svelte(content);
-				svelte.ensureScript(ast, { language });
-				js.imports.addEmpty(ast.instance.content, { from: stylesheetRelative });
-
-				if (content.length === 0) {
-					const svelteVersion = dependencyVersion('svelte');
-					if (!svelteVersion) throw new Error('Failed to determine svelte version');
-					svelte.addSlot(ast, {
-						svelteVersion
-					});
-				}
-
-				return generateCode();
-			});
+			sv.file(
+				layoutSvelte,
+				transforms.svelteScript({ language }, ({ ast, svelte, js }) => {
+					js.imports.addEmpty(ast.instance.content, { from: stylesheetRelative });
+
+					if (ast.fragment.nodes.length === 0) {
+						const svelteVersion = dependencyVersion('svelte');
+						if (!svelteVersion) throw new Error('Failed to determine svelte version');
+						svelte.addSlot(ast, { svelteVersion });
+					}
+				})
+			);
+		} else {
+			const appSvelte = `${directory.src}/App.svelte`;
+			const stylesheetRelative = file.getRelative({ from: appSvelte, to: file.stylesheet });
+			sv.file(
+				appSvelte,
+				transforms.svelteScript({ language }, ({ ast, js }) => {
+					js.imports.addEmpty(ast.instance.content, { from: stylesheetRelative });
+				})
+			);
 		}
 
-		sv.file(file.vscodeSettings, (content) => {
-			const { data, generateCode } = parse.json(content);
-
-			data['files.associations'] ??= {};
-			data['files.associations']['*.css'] = 'tailwindcss';
-
-			return generateCode();
-		});
-
-		sv.file(file.vscodeExtensions, (content) => {
-			const { data, generateCode } = parse.json(content);
-			json.arrayUpsert(data, 'recommendations', 'bradlc.vscode-tailwindcss');
-			return generateCode();
-		});
+		sv.file(
+			file.vscodeSettings,
+			transforms.json(({ data }) => {
+				data['files.associations'] ??= {};
+				data['files.associations']['*.css'] = 'tailwindcss';
+			})
+		);
+
+		sv.file(
+			file.vscodeExtensions,
+			transforms.json(({ data, json }) => {
+				json.arrayUpsert(data, 'recommendations', 'bradlc.vscode-tailwindcss');
+			})
+		);
 
 		if (prettierInstalled) {
-			sv.file(file.prettierrc, (content) => {
-				const { data, generateCode } = parse.json(content);
-
-				json.arrayUpsert(data, 'plugins', 'prettier-plugin-tailwindcss');
-				data.tailwindStylesheet ??= file.getRelative({ to: file.stylesheet });
-
-				return generateCode();
-			});
+			sv.file(
+				file.prettierrc,
+				transforms.json(({ data, json }) => {
+					json.arrayUpsert(data, 'plugins', 'prettier-plugin-tailwindcss');
+					data.tailwindStylesheet ??= file.getRelative({ to: file.stylesheet });
+				})
+			);
 		}
 	}
 });
diff --git a/packages/sv/src/addons/vitest-addon.ts b/packages/sv/src/addons/vitest-addon.ts
index 43e840e4c..fdd211226 100644
--- a/packages/sv/src/addons/vitest-addon.ts
+++ b/packages/sv/src/addons/vitest-addon.ts
@@ -1,4 +1,4 @@
-import { color, dedent, js, parse, json } from '@sveltejs/sv-utils';
+import { color, createPrinter, dedent, transforms } from '@sveltejs/sv-utils';
 import { defineAddon, defineAddonOptions } from '../core/config.ts';
 
 const options = defineAddonOptions()
@@ -40,146 +40,156 @@ export default defineAddon({
 			sv.devDependency('playwright', '^1.58.2');
 		}
 
-		sv.file(file.package, (content) => {
-			const { data, generateCode } = parse.json(content);
-
-			json.packageScriptsUpsert(data, 'test:unit', 'vitest');
-			// we use `--run` so that vitest doesn't run in watch mode when running `npm run test`
-			json.packageScriptsUpsert(data, 'test', 'npm run test:unit -- --run', { mode: 'prepend' });
-
-			return generateCode();
-		});
+		sv.file(
+			file.package,
+			transforms.json(({ data, json }) => {
+				json.packageScriptsUpsert(data, 'test:unit', 'vitest');
+				// we use `--run` so that vitest doesn't run in watch mode when running `npm run test`
+				json.packageScriptsUpsert(data, 'test', 'npm run test:unit -- --run', { mode: 'prepend' });
+			})
+		);
 
 		const examplesDir = `${directory.lib}/vitest-examples`;
-		const typed = language === 'ts';
+		const [ts] = createPrinter(language === 'ts');
 
 		if (unitTesting || componentTesting) {
-			sv.file(`${examplesDir}/greet.${language}`, (content) => {
-				if (content) return content;
-
-				return dedent`
-					export function greet(${typed ? 'name: string' : 'name'})${typed ? ': string' : ''} {
-						return 'Hello, ' + name + '!';
-					}
-				`;
-			});
+			sv.file(
+				`${examplesDir}/greet.${language}`,
+				transforms.text(({ content }) => {
+					if (content) return false;
+
+					return dedent`
+						export function greet(name${ts(': string')})${ts(': string')} {
+							return 'Hello, ' + name + '!';
+						}
+					`;
+				})
+			);
 		}
 
 		if (unitTesting) {
-			sv.file(`${examplesDir}/greet.spec.${language}`, (content) => {
-				if (content) return content;
+			sv.file(
+				`${examplesDir}/greet.spec.${language}`,
+				transforms.text(({ content }) => {
+					if (content) return false;
 
-				return dedent`
-					import { describe, it, expect } from 'vitest';
-					import { greet } from './greet';
+					return dedent`
+						import { describe, it, expect } from 'vitest';
+						import { greet } from './greet';
 
-					describe('greet', () => {
-						it('returns a greeting', () => {
-							expect(greet('Svelte')).toBe('Hello, Svelte!');
+						describe('greet', () => {
+							it('returns a greeting', () => {
+								expect(greet('Svelte')).toBe('Hello, Svelte!');
+							});
 						});
-					});
-				`;
-			});
+					`;
+				})
+			);
 		}
 
 		if (componentTesting) {
-			sv.file(`${examplesDir}/Welcome.svelte`, (content) => {
-				if (content) return content;
+			sv.file(
+				`${examplesDir}/Welcome.svelte`,
+				transforms.text(({ content }) => {
+					if (content) return false;
 
-				return dedent`
-					<script>
-						import { greet } from './greet';
+					return dedent`
+						<script>
+							import { greet } from './greet';
 
-						let { host = 'SvelteKit', guest = 'Vitest' } = $props();
-					</script>
+							let { host = 'SvelteKit', guest = 'Vitest' } = $props();
+						</script>
 
-					<h1>{greet(host)}</h1>
-					<p>{greet(guest)}</p>
-				`;
-			});
+						<h1>{greet(host)}</h1>
+						<p>{greet(guest)}</p>
+					`;
+				})
+			);
 
-			sv.file(`${examplesDir}/Welcome.svelte.spec.${language}`, (content) => {
-				if (content) return content;
+			sv.file(
+				`${examplesDir}/Welcome.svelte.spec.${language}`,
+				transforms.text(({ content }) => {
+					if (content) return false;
 
-				return dedent`
-					import { page } from 'vitest/browser';
-					import { describe, expect, it } from 'vitest';
-					import { render } from 'vitest-browser-svelte';
-					import Welcome from './Welcome.svelte';
+					return dedent`
+						import { page } from 'vitest/browser';
+						import { describe, expect, it } from 'vitest';
+						import { render } from 'vitest-browser-svelte';
+						import Welcome from './Welcome.svelte';
 
-					describe('Welcome.svelte', () => {
-						it('renders greetings for host and guest', async () => {
-							render(Welcome, { host: 'SvelteKit', guest: 'Vitest' });
+						describe('Welcome.svelte', () => {
+							it('renders greetings for host and guest', async () => {
+								render(Welcome, { host: 'SvelteKit', guest: 'Vitest' });
 
-							await expect.element(page.getByRole('heading', { level: 1 })).toHaveTextContent('Hello, SvelteKit!');
-							await expect.element(page.getByText('Hello, Vitest!')).toBeInTheDocument();
+								await expect.element(page.getByRole('heading', { level: 1 })).toHaveTextContent('Hello, SvelteKit!');
+								await expect.element(page.getByText('Hello, Vitest!')).toBeInTheDocument();
+							});
 						});
-					});
-				`;
-			});
+					`;
+				})
+			);
 		}
 
-		sv.file(file.viteConfig, (content) => {
-			const { ast, generateCode } = parse.script(content);
-
-			const clientObjectExpression = js.object.create({
-				extends: `./${file.viteConfig}`,
-				test: {
-					name: 'client',
-					browser: {
-						enabled: true,
-						provider: js.functions.createCall({ name: 'playwright', args: [] }),
-						instances: [{ browser: 'chromium', headless: true }]
-					},
-					include: ['src/**/*.svelte.{test,spec}.{js,ts}'],
-					exclude: ['src/lib/server/**']
-				}
-			});
-
-			const serverObjectExpression = js.object.create({
-				extends: `./${file.viteConfig}`,
-				test: {
-					name: 'server',
-					environment: 'node',
-					include: ['src/**/*.{test,spec}.{js,ts}'],
-					exclude: ['src/**/*.svelte.{test,spec}.{js,ts}']
-				}
-			});
-
-			const viteConfig = js.vite.getConfig(ast);
-
-			const testObject = js.object.property(viteConfig, {
-				name: 'test',
-				fallback: js.object.create({
-					expect: {
-						requireAssertions: true
+		sv.file(
+			file.viteConfig,
+			transforms.script(({ ast, js }) => {
+				const clientObjectExpression = js.object.create({
+					extends: `./${file.viteConfig}`,
+					test: {
+						name: 'client',
+						browser: {
+							enabled: true,
+							provider: js.functions.createCall({ name: 'playwright', args: [] }),
+							instances: [{ browser: 'chromium', headless: true }]
+						},
+						include: ['src/**/*.svelte.{test,spec}.{js,ts}'],
+						exclude: ['src/lib/server/**']
 					}
-				})
-			});
-
-			const workspaceArray = js.object.property(testObject, {
-				name: 'projects',
-				fallback: js.array.create()
-			});
-
-			if (componentTesting) js.array.append(workspaceArray, clientObjectExpression);
-			if (unitTesting) js.array.append(workspaceArray, serverObjectExpression);
-
-			// Manage imports
-			if (componentTesting)
-				js.imports.addNamed(ast, { imports: ['playwright'], from: '@vitest/browser-playwright' });
-			const importName = 'defineConfig';
-			const { statement, alias } = js.imports.find(ast, { name: importName, from: 'vite' });
-			if (statement) {
-				// Switch the import from 'vite' to 'vitest/config' (keeping the alias)
-				js.imports.addNamed(ast, { imports: { defineConfig: alias }, from: 'vitest/config' });
-
-				// Remove the old import
-				js.imports.remove(ast, { name: importName, from: 'vite', statement });
-			}
-
-			return generateCode();
-		});
+				});
+
+				const serverObjectExpression = js.object.create({
+					extends: `./${file.viteConfig}`,
+					test: {
+						name: 'server',
+						environment: 'node',
+						include: ['src/**/*.{test,spec}.{js,ts}'],
+						exclude: ['src/**/*.svelte.{test,spec}.{js,ts}']
+					}
+				});
+
+				const viteConfig = js.vite.getConfig(ast);
+
+				const testObject = js.object.property(viteConfig, {
+					name: 'test',
+					fallback: js.object.create({
+						expect: {
+							requireAssertions: true
+						}
+					})
+				});
+
+				const workspaceArray = js.object.property(testObject, {
+					name: 'projects',
+					fallback: js.array.create()
+				});
+
+				if (componentTesting) js.array.append(workspaceArray, clientObjectExpression);
+				if (unitTesting) js.array.append(workspaceArray, serverObjectExpression);
+
+				// Manage imports
+				if (componentTesting)
+					js.imports.addNamed(ast, { imports: ['playwright'], from: '@vitest/browser-playwright' });
+				const importName = 'defineConfig';
+				const { statement, alias } = js.imports.find(ast, { name: importName, from: 'vite' });
+				if (statement) {
+					// Switch the import from 'vite' to 'vitest/config' (keeping the alias)
+					js.imports.addNamed(ast, { imports: { defineConfig: alias }, from: 'vitest/config' });
+
+					// Remove the old import
+					js.imports.remove(ast, { name: importName, from: 'vite', statement });
+				}
+			})
+		);
 	},
 
 	nextSteps: ({ language, options }) => {
diff --git a/packages/sv/src/cli/tests/snapshots/@my-org/sv/src/index.js b/packages/sv/src/cli/tests/snapshots/@my-org/sv/src/index.js
index d1755e9e6..abc552237 100644
--- a/packages/sv/src/cli/tests/snapshots/@my-org/sv/src/index.js
+++ b/packages/sv/src/cli/tests/snapshots/@my-org/sv/src/index.js
@@ -1,4 +1,4 @@
-import { js, parse, svelte } from '@sveltejs/sv-utils';
+import { transforms } from '@sveltejs/sv-utils';
 import { defineAddon, defineAddonOptions } from 'sv';
 
 const options = defineAddonOptions()
@@ -18,34 +18,36 @@ export default defineAddon({
 	},
 
 	run: ({ directory, sv, options, language }) => {
-		sv.file(`${directory.lib}/@my-org/sv/content.txt`, () => {
-			return `This is a text file made by the Community Addon Template demo for the add-on: '@my-org/sv'!`;
-		});
-
-		sv.file(`${directory.lib}/@my-org/sv/HelloComponent.svelte`, (content) => {
-			const { ast, generateCode } = parse.svelte(content);
-			svelte.ensureScript(ast, { language });
-
-			js.imports.addDefault(ast.instance.content, { as: 'content', from: './content.txt?raw' });
-
-			svelte.addFragment(ast, '<p>{content}</p>');
-			svelte.addFragment(ast, `<h2>Hello ${options.who}!</h2>`);
-
-			return generateCode();
-		});
-
-		sv.file(directory.kitRoutes + '/+page.svelte', (content) => {
-			const { ast, generateCode } = parse.svelte(content);
-			svelte.ensureScript(ast, { language });
-
-			js.imports.addDefault(ast.instance.content, {
-				as: 'HelloComponent',
-				from: `$lib/@my-org/sv/HelloComponent.svelte`
-			});
-
-			svelte.addFragment(ast, '<HelloComponent />');
-
-			return generateCode();
-		});
+		sv.file(
+			`${directory.lib}/@my-org/sv/content.txt`,
+			transforms.text(() => {
+				return `This is a text file made by the Community Addon Template demo for the add-on: '@my-org/sv'!`;
+			})
+		);
+
+		sv.file(
+			`${directory.lib}/@my-org/sv/HelloComponent.svelte`,
+			transforms.svelteScript({ language }, ({ ast, svelte, js }) => {
+				js.imports.addDefault(ast.instance.content, {
+					as: 'content',
+					from: './content.txt?raw'
+				});
+
+				svelte.addFragment(ast, '<p>{content}</p>');
+				svelte.addFragment(ast, `<h2>Hello ${options.who}!</h2>`);
+			})
+		);
+
+		sv.file(
+			directory.kitRoutes + '/+page.svelte',
+			transforms.svelteScript({ language }, ({ ast, svelte, js }) => {
+				js.imports.addDefault(ast.instance.content, {
+					as: 'HelloComponent',
+					from: `$lib/@my-org/sv/HelloComponent.svelte`
+				});
+
+				svelte.addFragment(ast, '<HelloComponent />');
+			})
+		);
 	}
 });
diff --git a/packages/sv/src/core/config.ts b/packages/sv/src/core/config.ts
index a89e4a9a6..5963eedbb 100644
--- a/packages/sv/src/core/config.ts
+++ b/packages/sv/src/core/config.ts
@@ -29,8 +29,12 @@ export type SvApi = {
 	devDependency: (pkg: string, version: string) => void;
 	/** Execute a command in the workspace. */
 	execute: (args: string[], stdio: 'inherit' | 'pipe') => Promise<void>;
-	/** Edit a file in the workspace. (will create it if it doesn't exist) */
-	file: (path: string, edit: (content: string) => string) => void;
+	/**
+	 * Edit a file in the workspace. (will create it if it doesn't exist)
+	 *
+	 * Return `false` from the callback to abort - the original content is returned unchanged.
+	 */
+	file: (path: string, edit: (content: string) => string | false) => void;
 };
 
 export type Addon<Args extends OptionDefinition, Id extends string = string> = {
diff --git a/packages/sv/src/core/engine.ts b/packages/sv/src/core/engine.ts
index e5403a49a..1c7656467 100644
--- a/packages/sv/src/core/engine.ts
+++ b/packages/sv/src/core/engine.ts
@@ -178,15 +178,13 @@ async function runAddon({ addon, loaded, multiple, workspace, workspaceOptions }
 	const dependencies: Array<{ pkg: string; version: string; dev: boolean }> = [];
 	const pnpmBuildDependencies: string[] = [];
 	const sv: SvApi = {
-		file: (path, content) => {
+		file: (path, edit) => {
 			try {
-				const exists = fileExists(workspace.cwd, path);
-				let fileContent = exists ? readFile(workspace.cwd, path) : '';
-				// process file
-				fileContent = content(fileContent);
-				if (!fileContent) return fileContent;
+				const content = fileExists(workspace.cwd, path) ? readFile(workspace.cwd, path) : '';
+				const editedContent = edit(content);
+				if (editedContent === '' || editedContent === false) return content;
 
-				writeFile(workspace.cwd, path, fileContent);
+				writeFile(workspace.cwd, path, editedContent);
 				files.add(path);
 			} catch (e) {
 				if (e instanceof Error) {
diff --git a/packages/sv/src/create/templates/addon/src/index.js b/packages/sv/src/create/templates/addon/src/index.js
index 463b2b900..28e4cac1d 100644
--- a/packages/sv/src/create/templates/addon/src/index.js
+++ b/packages/sv/src/create/templates/addon/src/index.js
@@ -1,4 +1,4 @@
-import { js, parse, svelte } from '@sveltejs/sv-utils';
+import { transforms } from '@sveltejs/sv-utils';
 import { defineAddon, defineAddonOptions } from 'sv';
 
 const options = defineAddonOptions()
@@ -18,34 +18,36 @@ export default defineAddon({
 	},
 
 	run: ({ directory, sv, options, language }) => {
-		sv.file(`${directory.lib}/~SV-NAME-TODO~/content.txt`, () => {
-			return `This is a text file made by the Community Addon Template demo for the add-on: '~SV-NAME-TODO~'!`;
-		});
-
-		sv.file(`${directory.lib}/~SV-NAME-TODO~/HelloComponent.svelte`, (content) => {
-			const { ast, generateCode } = parse.svelte(content);
-			svelte.ensureScript(ast, { language });
-
-			js.imports.addDefault(ast.instance.content, { as: 'content', from: './content.txt?raw' });
-
-			svelte.addFragment(ast, '<p>{content}</p>');
-			svelte.addFragment(ast, `<h2>Hello ${options.who}!</h2>`);
-
-			return generateCode();
-		});
-
-		sv.file(directory.kitRoutes + '/+page.svelte', (content) => {
-			const { ast, generateCode } = parse.svelte(content);
-			svelte.ensureScript(ast, { language });
-
-			js.imports.addDefault(ast.instance.content, {
-				as: 'HelloComponent',
-				from: `$lib/~SV-NAME-TODO~/HelloComponent.svelte`
-			});
-
-			svelte.addFragment(ast, '<HelloComponent />');
-
-			return generateCode();
-		});
+		sv.file(
+			`${directory.lib}/~SV-NAME-TODO~/content.txt`,
+			transforms.text(() => {
+				return `This is a text file made by the Community Addon Template demo for the add-on: '~SV-NAME-TODO~'!`;
+			})
+		);
+
+		sv.file(
+			`${directory.lib}/~SV-NAME-TODO~/HelloComponent.svelte`,
+			transforms.svelteScript({ language }, ({ ast, svelte, js }) => {
+				js.imports.addDefault(ast.instance.content, {
+					as: 'content',
+					from: './content.txt?raw'
+				});
+
+				svelte.addFragment(ast, '<p>{content}</p>');
+				svelte.addFragment(ast, `<h2>Hello ${options.who}!</h2>`);
+			})
+		);
+
+		sv.file(
+			directory.kitRoutes + '/+page.svelte',
+			transforms.svelteScript({ language }, ({ ast, svelte, js }) => {
+				js.imports.addDefault(ast.instance.content, {
+					as: 'HelloComponent',
+					from: `$lib/~SV-NAME-TODO~/HelloComponent.svelte`
+				});
+
+				svelte.addFragment(ast, '<HelloComponent />');
+			})
+		);
 	}
 });