Merge pull request #12 from LukeHagar/swap-to-handler

2025-12-06 12:47:48 +00:00 · 2025-07-23 16:49:23 -05:00
parent 87c8ceb458 197a2e3f1d
commit da7e368a9a
31 changed files with 9020 additions and 5108 deletions
--- a/.github/ISSUE_TEMPLATE/bug_report.yml
+++ b/.github/ISSUE_TEMPLATE/bug_report.yml
@@ -0,0 +1,209 @@
+name: Bug Report
+description: Report a bug with SvelteKit Electron or Appwrite adapters
+title: "[BUG] "
+labels: ["bug", "triage"]
+assignees: []
+
+body:
+  - type: markdown
+    attributes:
+      value: |
+        Thanks for taking the time to fill out this bug report! Please provide as much detail as possible to help us reproduce and fix the issue.
+
+  - type: dropdown
+    id: adapter
+    attributes:
+      label: Which adapter is affected?
+      description: Select the adapter you're having issues with
+      options:
+        - adapter-electron
+        - adapter-appwrite
+        - Both adapters
+        - Not sure
+    validations:
+      required: true
+
+  - type: textarea
+    id: description
+    attributes:
+      label: Describe the bug
+      description: A clear and concise description of what the bug is
+      placeholder: Tell us what happened!
+    validations:
+      required: true
+
+  - type: textarea
+    id: reproduction
+    attributes:
+      label: Steps to reproduce
+      description: Steps to reproduce the behavior
+      placeholder: |
+        1. Go to '...'
+        2. Click on '...'
+        3. Scroll down to '...'
+        4. See error
+    validations:
+      required: true
+
+  - type: textarea
+    id: expected
+    attributes:
+      label: Expected behavior
+      description: A clear and concise description of what you expected to happen
+      placeholder: What should have happened?
+    validations:
+      required: true
+
+  - type: textarea
+    id: actual
+    attributes:
+      label: Actual behavior
+      description: What actually happened instead
+      placeholder: What actually happened?
+    validations:
+      required: true
+
+  - type: textarea
+    id: error-logs
+    attributes:
+      label: Error logs
+      description: If applicable, paste any error messages or stack traces
+      placeholder: |
+        Paste error logs here...
+      render: shell
+
+  - type: textarea
+    id: screenshots
+    attributes:
+      label: Screenshots
+      description: If applicable, add screenshots to help explain your problem
+      placeholder: Drag and drop screenshots here
+
+  - type: input
+    id: os
+    attributes:
+      label: Operating System
+      description: What OS are you running?
+      placeholder: e.g. Windows 11, macOS 14.1, Ubuntu 22.04
+    validations:
+      required: true
+
+  - type: input
+    id: node-version
+    attributes:
+      label: Node.js version
+      description: What version of Node.js are you using?
+      placeholder: e.g. 18.17.0, 20.9.0
+    validations:
+      required: true
+
+  - type: input
+    id: electron-version
+    attributes:
+      label: Electron version (if using adapter-electron)
+      description: What version of Electron are you using?
+      placeholder: e.g. 28.0.0, 29.1.0
+
+  - type: input
+    id: sveltekit-version
+    attributes:
+      label: SvelteKit version
+      description: What version of SvelteKit are you using?
+      placeholder: e.g. 2.0.0, 2.5.0
+    validations:
+      required: true
+
+  - type: input
+    id: adapter-version
+    attributes:
+      label: Adapter version
+      description: What version of the adapter are you using?
+      placeholder: e.g. 0.1.0, 1.0.0
+    validations:
+      required: true
+
+  - type: dropdown
+    id: environment
+    attributes:
+      label: Environment
+      description: In which environment does this issue occur?
+      options:
+        - Development (npm run dev)
+        - Production build (npm run build)
+        - Both development and production
+        - Not sure
+    validations:
+      required: true
+
+  - type: textarea
+    id: config
+    attributes:
+      label: Configuration
+      description: Please share your relevant configuration files
+      placeholder: |
+        svelte.config.js:
+        ```js
+        // paste your svelte.config.js here
+        ```
+        
+        vite.config.js:
+        ```js
+        // paste your vite.config.js here
+        ```
+        
+        package.json (relevant sections):
+        ```json
+        // paste relevant parts of package.json
+        ```
+      render: javascript
+
+  - type: textarea
+    id: minimal-reproduction
+    attributes:
+      label: Minimal reproduction
+      description: |
+        If possible, provide a minimal reproduction of the issue. This could be:
+        - A link to a GitHub repository
+        - A CodeSandbox/StackBlitz link
+        - Minimal code snippets
+      placeholder: |
+        Link to reproduction: https://github.com/...
+        
+        Or paste minimal code here:
+        ```js
+        // minimal reproduction code
+        ```
+
+  - type: textarea
+    id: workaround
+    attributes:
+      label: Workaround
+      description: If you found a workaround, please describe it here
+      placeholder: Describe any workarounds you've found
+
+  - type: textarea
+    id: additional-context
+    attributes:
+      label: Additional context
+      description: Add any other context about the problem here
+      placeholder: |
+        Any additional information that might be helpful:
+        - Related issues
+        - Recent changes to your setup
+        - Browser console errors (if applicable)
+        - Network requests (if applicable)
+
+  - type: checkboxes
+    id: checklist
+    attributes:
+      label: Pre-submission checklist
+      description: Please check the following before submitting
+      options:
+        - label: I have searched existing issues to make sure this is not a duplicate
+          required: true
+        - label: I have provided all the requested information above
+          required: true
+        - label: I have tested this with the latest version of the adapter
+          required: true
+        - label: I have included a minimal reproduction (if possible)
+          required: false 
--- a/.github/ISSUE_TEMPLATE/feature_request.yml
+++ b/.github/ISSUE_TEMPLATE/feature_request.yml
@@ -0,0 +1,130 @@
+name: Feature Request
+description: Suggest a new feature or enhancement for SvelteKit adapters
+title: "[FEATURE] "
+labels: ["enhancement", "triage"]
+assignees: []
+
+body:
+  - type: markdown
+    attributes:
+      value: |
+        Thanks for suggesting a new feature! Please provide as much detail as possible to help us understand your request.
+
+  - type: dropdown
+    id: adapter
+    attributes:
+      label: Which adapter is this feature for?
+      description: Select the adapter this feature request relates to
+      options:
+        - adapter-electron
+        - adapter-appwrite
+        - Both adapters
+        - New adapter
+        - General/Core
+    validations:
+      required: true
+
+  - type: textarea
+    id: problem
+    attributes:
+      label: Is your feature request related to a problem?
+      description: A clear and concise description of what the problem is
+      placeholder: I'm always frustrated when...
+    validations:
+      required: true
+
+  - type: textarea
+    id: solution
+    attributes:
+      label: Describe the solution you'd like
+      description: A clear and concise description of what you want to happen
+      placeholder: I would like...
+    validations:
+      required: true
+
+  - type: textarea
+    id: alternatives
+    attributes:
+      label: Describe alternatives you've considered
+      description: A clear and concise description of any alternative solutions or features you've considered
+      placeholder: Alternatively, we could...
+
+  - type: textarea
+    id: use-case
+    attributes:
+      label: Use case
+      description: Describe your specific use case and how this feature would help
+      placeholder: |
+        I'm building an application that...
+        This feature would help by...
+    validations:
+      required: true
+
+  - type: textarea
+    id: implementation
+    attributes:
+      label: Implementation ideas
+      description: If you have ideas on how this could be implemented, please share them
+      placeholder: |
+        This could be implemented by...
+        
+        ```js
+        // Example API or code structure
+        ```
+
+  - type: dropdown
+    id: priority
+    attributes:
+      label: Priority
+      description: How important is this feature to you?
+      options:
+        - Low - Nice to have
+        - Medium - Would be helpful
+        - High - Needed for my project
+        - Critical - Blocking my work
+    validations:
+      required: true
+
+  - type: dropdown
+    id: complexity
+    attributes:
+      label: Estimated complexity
+      description: How complex do you think this feature would be to implement?
+      options:
+        - Low - Simple configuration or small addition
+        - Medium - Moderate changes to existing code
+        - High - Significant changes or new architecture
+        - Not sure
+
+  - type: textarea
+    id: examples
+    attributes:
+      label: Examples from other tools
+      description: Are there similar features in other tools or frameworks that we could reference?
+      placeholder: |
+        Similar to how [tool] does [feature]...
+        Link: https://...
+
+  - type: textarea
+    id: additional-context
+    attributes:
+      label: Additional context
+      description: Add any other context, screenshots, or mockups about the feature request here
+      placeholder: |
+        Any additional information:
+        - Related issues or discussions
+        - Screenshots or mockups
+        - Links to relevant documentation
+
+  - type: checkboxes
+    id: checklist
+    attributes:
+      label: Pre-submission checklist
+      description: Please check the following before submitting
+      options:
+        - label: I have searched existing issues to make sure this is not a duplicate
+          required: true
+        - label: I have provided a clear description of the problem and solution
+          required: true
+        - label: I have described my specific use case
+          required: true 
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -21,13 +21,16 @@ jobs:
      - name: Checkout Repo
        uses: actions/checkout@v3

-      - name: setup node.js 20
-        uses: actions/setup-node@v3
+      - name: Install pnpm
+        uses: pnpm/action-setup@v4.1.0
        with:
-          node-version: 20
-
-      - name: install pnpm
-        run: npm i pnpm@latest -g
+          version: 10
+            
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: 22
+          cache: 'pnpm'

      - name: install dependencies
        run: pnpm install
--- a/.github/workflows/test.yml
+++ b/.github/workflows/test.yml
@@ -0,0 +1,69 @@
+name: CI Tests
+
+on:
+  pull_request:
+    branches: [ main ]
+
+jobs:
+  run-workspace-tests:
+    name: Run workspace tests
+    runs-on: ubuntu-latest
+    
+    steps:
+    - name: Checkout code
+      uses: actions/checkout@v4
+      
+    - name: Install pnpm
+      uses: pnpm/action-setup@v4.1.0
+      with:
+        version: 8
+        
+    - name: Setup Node.js
+      uses: actions/setup-node@v4
+      with:
+        node-version: 22
+        cache: 'pnpm'
+        
+    - name: Install dependencies
+      run: pnpm install
+      
+    - name: Run workspace tests
+      run: pnpm -r test
+
+  build-test:
+    name: Run Build Tests
+    runs-on: ubuntu-latest
+    
+    steps:
+    - name: Checkout code
+      uses: actions/checkout@v4
+      
+    - name: Install pnpm
+      uses: pnpm/action-setup@v4.1.0
+      with:
+        version: 10
+        
+    - name: Setup Node.js
+      uses: actions/setup-node@v4
+      with:
+        node-version: 22
+        cache: 'pnpm'
+        
+    - name: Install dependencies
+      run: pnpm install
+      
+    - name: Build electron example
+      run: |
+        cd examples/electron
+        pnpm run build
+        
+    - name: Validate build output
+      run: |
+        cd examples/electron
+        # Check that required files exist
+        test -d "out/client" || (echo "❌ Missing client directory" && exit 1)
+        test -f "out/server/index.js" || (echo "❌ Missing server/index.js" && exit 1)
+        test -f "out/server/manifest.js" || (echo "❌ Missing server/manifest.js" && exit 1)
+        test -f "out/main/index.cjs" || (echo "❌ Missing main/index.js" && exit 1)
+        test -f "out/preload/index.js" || (echo "❌ Missing preload/index.js" && exit 1)
+        echo "✅ All required build files exist"
--- a/README.md
+++ b/README.md
@@ -14,10 +14,16 @@ I have tested and validated the implementation with the node20 runtime. Other ru

 [Adapter](https://github.com/LukeHagar/sveltekit-adapters/tree/main/packages/adapter-electron) | [Example](https://github.com/LukeHagar/sveltekit-adapters/tree/main/examples/electron)  

-Deploy SvelteKit applications as electron desktop applications.
+Deploy SvelteKit applications as Electron desktop applications with native protocol handling.

-This adapter does require additional files to be added to the project, and requires the use of the package `electron-vite` to properly handle the electron implementation.  
-Please look at the [example](https://github.com/LukeHagar/sveltekit-adapters/tree/main/examples/electron) implementation for more information.
+This adapter provides seamless integration between SvelteKit and Electron, featuring:
+- **Native Protocol Handling**: Uses Electron's `protocol.handle()` API for production
+- **Development Integration**: Seamless Vite dev server integration with hot module replacement
+- **Full SvelteKit Support**: SSR, API routes, static assets, prerendered pages, and form actions
+- **Clean Architecture**: All Electron integration code is encapsulated
+- **Production Ready**: Works with electron-builder and similar packaging tools
+
+The adapter automatically handles the build process and provides helper functions for setting up the Electron main process. Please look at the [example](https://github.com/LukeHagar/sveltekit-adapters/tree/main/examples/electron) implementation for detailed setup instructions.

 ## What's inside?

@@ -26,9 +32,9 @@ This repo includes the following packages and examples:
 ### Examples

 - `appwrite`: a [SvelteKit](https://kit.svelte.dev) example app that uses the `adapter-appwrite` adapter [[Link](https://github.com/LukeHagar/sveltekit-adapters/tree/main/examples/appwrite)]  
- `electron`: a [SvelteKit](https://kit.svelte.dev) example app that uses the `adapter-electron` adapter [[Link](https://github.com/LukeHagar/sveltekit-adapters/tree/main/examples/electron)]
+- `electron`: a [SvelteKit](https://kit.svelte.dev) example app that uses the `adapter-electron` adapter with native protocol handling [[Link](https://github.com/LukeHagar/sveltekit-adapters/tree/main/examples/electron)]

 ### Packages

 - `adapter-appwrite`: a [SvelteKit](https://kit.svelte.dev) adapter for deploying applications as appwrite functions [[Link](https://github.com/LukeHagar/sveltekit-adapters/tree/main/packages/adapter-appwrite)]
- `adapter-electron`: a [SvelteKit](https://kit.svelte.dev) adapter for deploying applications as electron desktop applications [[Link](https://github.com/LukeHagar/sveltekit-adapters/tree/main/packages/adapter-electron)]
+- `adapter-electron`: a [SvelteKit](https://kit.svelte.dev) adapter for deploying applications as Electron desktop applications with native protocol handling and Vite integration [[Link](https://github.com/LukeHagar/sveltekit-adapters/tree/main/packages/adapter-electron)]
--- a/examples/electron/electron-builder.yaml
+++ b/examples/electron/electron-builder.yaml
@@ -6,13 +6,16 @@ files:
  - "!**/.vscode/*"
  - "!src/*"
  - "!electron.vite.config.{js,ts,mjs,cjs}"
+  - "!vite.electron.config.ts"
  - "!{.eslintignore,.eslintrc.cjs,.prettierignore,.prettierrc.yaml,dev-app-update.yml,CHANGELOG.md,README.md}"
  - "!{.env,.env.*,.npmrc,pnpm-lock.yaml}"
  - "!{tsconfig.json,tsconfig.node.json,tsconfig.web.json}"
+  - "out/**/*"
 asarUnpack:
  - resources/**
 # afterSign: build/notarize.js
 win:
+  target: ["portable"]
  executableName: electron-sveltekit
 nsis:
  artifactName: ${name}-${version}-setup.${ext}
--- a/examples/electron/electron.vite.config.ts
+++ b/examples/electron/electron.vite.config.ts
@@ -1,8 +0,0 @@
-import { defineConfig, defineViteConfig } from 'electron-vite';
-import config from './vite.config';
-
-export default defineConfig({
-	main: defineViteConfig({}),
-	preload: defineViteConfig({}),
-	renderer: config
-});
--- a/examples/electron/package.json
+++ b/examples/electron/package.json
@@ -7,44 +7,48 @@
 		"name": "Luke Hagar",
 		"email": "lukeslakemail@gmail.com"
 	},
-	"main": "./out/main/index.js",
+	"homepage": "https://github.com/lukehagar/sveltekit-adapters",
+	"main": "./out/main/index.cjs",
 	"scripts": {
-		"start": "electron-vite preview",
-		"dev": "electron-vite dev",
-		"build": "electron-vite build",
-		"build:win": "npm run build && electron-builder --win --config",
-		"build:mac": "npm run build && electron-builder --mac --config",
-		"build:linux": "npm run build && electron-builder --linux --config"
+		"start": "vite preview",
+		"sync": "svelte-kit sync",
+		"dev": "pnpm sync && concurrently \"vite dev\" \"electron .\" --names \"sveltekit,electron\" --prefix-colors \"#ff3e00,blue\"",
+		"build": "pnpm sync && vite build",
+		"build:all": "pnpm build && electron-builder -mwl --config",
+		"build:win": "pnpm build && electron-builder --win --config",
+		"build:mac": "pnpm build && electron-builder --mac --config",
+		"build:linux": "pnpm build && electron-builder --linux --config"
 	},
 	"devDependencies": {
-		"@fontsource/fira-mono": "^5.0.8",
-		"@neoconfetti/svelte": "^2.2.1",
-		"@sveltejs/kit": "^2.5.0",
-		"@sveltejs/vite-plugin-svelte": "^3.0.2",
-		"@types/eslint": "8.56.2",
-		"@typescript-eslint/eslint-plugin": "^7.0.1",
-		"@typescript-eslint/parser": "^7.0.1",
+		"@fontsource/fira-mono": "^5.2.6",
+		"@neoconfetti/svelte": "^2.2.2",
+		"@sveltejs/kit": "^2.22.2",
+		"@sveltejs/vite-plugin-svelte": "^5.1.0",
+		"@types/eslint": "9.6.1",
+		"@types/node": "^24.0.11",
+		"@typescript-eslint/eslint-plugin": "^8.35.1",
+		"@typescript-eslint/parser": "^8.35.1",
 		"adapter-electron": "workspace:*",
-		"concurrently": "^8.2.2",
+		"concurrently": "^9.2.0",
 		"cross-env": "^7.0.3",
-		"dotenv": "^16.4.4",
-		"electron": "^28.2.3",
-		"electron-builder": "^24.9.1",
+		"dotenv": "^17.0.1",
+		"electron": "^37.2.0",
+		"electron-builder": "^26.0.12",
 		"electron-is-dev": "^3.0.1",
-		"electron-log": "^5.1.1",
-		"electron-util": "^0.18.0",
-		"electron-vite": "^2.0.0",
-		"eslint": "^8.56.0",
-		"eslint-config-prettier": "^9.1.0",
-		"eslint-plugin-svelte": "^2.35.1",
+		"electron-log": "^5.4.1",
+		"electron-util": "^0.18.1",
+		"esbuild": "^0.25.0",
+		"eslint": "^9.30.1",
+		"eslint-config-prettier": "^10.1.5",
+		"eslint-plugin-svelte": "^3.10.1",
 		"polka": "^0.5.2",
-		"prettier": "^3.2.5",
-		"prettier-plugin-svelte": "^3.2.1",
-		"svelte": "^4.2.11",
-		"svelte-check": "^3.6.4",
-		"tslib": "^2.6.2",
-		"typescript": "^5.3.3",
-		"vite": "^5.1.3"
+		"prettier": "^3.6.2",
+		"prettier-plugin-svelte": "^3.4.0",
+		"svelte": "^5.35.1",
+		"svelte-check": "^4.2.2",
+		"tslib": "^2.8.1",
+		"typescript": "^5.8.3",
+		"vite": "^6.0.0"
 	},
 	"type": "module"
 }
--- a/examples/electron/src/main.ts
+++ b/examples/electron/src/main.ts
@@ -0,0 +1,59 @@
+import { app, BrowserWindow } from 'electron';
+import { setupHandler, getPreloadPath, registerAppScheme } from 'adapter-electron/functions/setupHandler';
+import log from 'electron-log/main';
+
+console.log = log.log;
+
+let mainWindow: BrowserWindow | null = null;
+let stopIntercept: (() => void) | undefined;
+
+process.on('SIGTERM', () => process.exit(0));
+process.on('SIGINT', () => process.exit(0));
+
+// First register the app scheme
+registerAppScheme();
+
+
+async function createWindow() {
+	// Create the browser window
+	mainWindow = new BrowserWindow({
+		width: 1200,
+		height: 800,
+		webPreferences: {
+			// Second configure the preload script
+			preload: getPreloadPath(),
+			contextIsolation: true,
+			devTools: true
+		}
+	});
+
+	mainWindow.once('ready-to-show', () => mainWindow?.webContents.openDevTools());
+
+	mainWindow.on('closed', () => {
+		mainWindow = null;
+		stopIntercept?.();
+	});
+
+	// Setup the handler
+	stopIntercept = await setupHandler(mainWindow);
+
+	return mainWindow;
+}
+
+app.on('ready', createWindow);
+
+app.on('window-all-closed', () => {
+	if (process.platform !== 'darwin') {
+		app.quit();
+	}
+});
+
+app.on('activate', async () => {
+	if (BrowserWindow.getAllWindows().length === 0 && !mainWindow) {
+		try {
+			await createWindow();
+		} catch (error) {
+			console.error('Failed to create window:', error);
+		}
+	}
+});
--- a/examples/electron/src/main/index.ts
+++ b/examples/electron/src/main/index.ts
@@ -1,45 +0,0 @@
-import { app, BrowserWindow } from 'electron';
-import { start, load } from 'adapter-electron/functions';
-import isDev from 'electron-is-dev';
-import log from 'electron-log/main';
-import nodePath from 'node:path';
-
-log.info('Hello, log!');
-const port = await start();
-
-async function createWindow() {
-	// Create the browser window
-
-	const mainWindow = new BrowserWindow({
-		width: 800,
-		height: 600,
-		webPreferences: {
-			preload: nodePath.join(__dirname, '../preload/index.mjs')
-		}
-	});
-
-	// Load the local URL for development or the local
-	// html file for production
-	load(mainWindow, port);
-
-	if (isDev) mainWindow.webContents.openDevTools();
-}
-
-app.whenReady().then(() => {
-	log.info('App is ready');
-
-	log.info('Creating window...');
-	createWindow();
-
-	app.on('activate', () => {
-		if (BrowserWindow.getAllWindows().length === 0) {
-			createWindow();
-		}
-	});
-});
-
-app.on('window-all-closed', () => {
-	if (process.platform !== 'darwin') {
-		app.quit();
-	}
-});
--- a/examples/electron/src/preload.ts
+++ b/examples/electron/src/preload.ts
@@ -0,0 +1 @@
+console.log('Preload loaded');
--- a/examples/electron/src/preload/index.ts
+++ b/examples/electron/src/preload/index.ts
@@ -1,10 +0,0 @@
-window.addEventListener('DOMContentLoaded', () => {
-	const replaceText = (selector, text) => {
-		const element = document.getElementById(selector);
-		if (element) element.innerText = text;
-	};
-
-	for (const type of ['chrome', 'node', 'electron']) {
-		replaceText(`${type}-version`, process.versions[type]);
-	}
-});
--- a/examples/electron/src/routes/sverdle/+page.server.ts
+++ b/examples/electron/src/routes/sverdle/+page.server.ts
@@ -3,25 +3,42 @@ import { Game } from './game';
 import type { PageServerLoad, Actions } from './$types';

 export const load = (({ cookies }) => {
-	const game = new Game(cookies.get('sverdle'));
+	console.log("Loading game, getting cookie");

-	return {
-		/**
-		 * The player's guessed words so far
-		 */
-		guesses: game.guesses,
+	try {
+		const game = new Game(cookies.get('sverdle'));

-		/**
-		 * An array of strings like '__x_c' corresponding to the guesses, where 'x' means
-		 * an exact match, and 'c' means a close match (right letter, wrong place)
-		 */
-		answers: game.answers,
+		const gameState = {
+			/**
+			 * The player's guessed words so far
+			 */
+			guesses: game.guesses,

-		/**
-		 * The correct answer, revealed if the game is over
-		 */
-		answer: game.answers.length >= 6 ? game.answer : null
-	};
+			/**
+			 * An array of strings like '__x_c' corresponding to the guesses, where 'x' means
+			 * an exact match, and 'c' means a close match (right letter, wrong place)
+			 */
+			answers: game.answers,
+
+			/**
+			 * The correct answer, revealed if the game is over
+			 */
+			answer: game.answers.length >= 6 ? game.answer : null
+		}
+
+		console.log("Returning game state", gameState);
+
+		return gameState
+	} catch (e) {
+		console.error("Error loading game state:", e);
+		// Return a new game state as fallback
+		const newGame = new Game();
+		return {
+			guesses: newGame.guesses,
+			answers: newGame.answers,
+			answer: null
+		};
+	}
 }) satisfies PageServerLoad;

 export const actions = {
@@ -30,6 +47,7 @@ export const actions = {
 	 * is available, this will happen in the browser instead of here
 	 */
 	update: async ({ request, cookies }) => {
+		console.log("Updating game, getting cookie");
 		const game = new Game(cookies.get('sverdle'));

 		const data = await request.formData();
@@ -43,7 +61,9 @@ export const actions = {
 			game.guesses[i] += key;
 		}

-		cookies.set('sverdle', game.toString(), { path: '/' });
+		const gameString = game.toString();
+		console.log("Setting cookie", gameString);
+		cookies.set('sverdle', gameString, { path: '/' });
 	},

 	/**
@@ -51,19 +71,27 @@ export const actions = {
 	 * the server, so that people can't cheat by peeking at the JavaScript
 	 */
 	enter: async ({ request, cookies }) => {
-		const game = new Game(cookies.get('sverdle'));
+		console.log("Entering guess, getting cookie");
+		try {
+			const game = new Game(cookies.get('sverdle'));

-		const data = await request.formData();
-		const guess = data.getAll('guess') as string[];
+			const data = await request.formData();
+			const guess = data.getAll('guess') as string[];

-		if (!game.enter(guess)) {
-			return fail(400, { badGuess: true });
+			if (!game.enter(guess)) {
+				return fail(400, { badGuess: true });
+			}
+
+			const gameString = game.toString();
+			console.log("Setting cookie", gameString);
+			cookies.set('sverdle', gameString, { path: '/' });
+		} catch (e) {
+			console.log("Error entering guess", e);
 		}
-
-		cookies.set('sverdle', game.toString(), { path: '/' });
 	},

 	restart: async ({ cookies }) => {
+		console.log("Restarting game, deleting cookie");
 		cookies.delete('sverdle', { path: '/' });
 	}
 } satisfies Actions;
--- a/examples/electron/tsconfig.json
+++ b/examples/electron/tsconfig.json
@@ -9,7 +9,10 @@
 		"skipLibCheck": true,
 		"sourceMap": true,
 		"strict": true,
-		"moduleResolution": "bundler"
+		"moduleResolution": "bundler",
+		"module": "ES2022",
+		"target": "ES2022",
+		"types": ["node", "electron"]
 	}
 	// Path aliases are handled by https://kit.svelte.dev/docs/configuration#alias
 	//
--- a/examples/electron/vite.config.ts
+++ b/examples/electron/vite.config.ts
@@ -1,7 +1,17 @@
 import { sveltekit } from '@sveltejs/kit/vite';
 import { defineConfig } from 'vite';
+import { electronPlugin } from 'adapter-electron';

 export default defineConfig({
-	logLevel: 'info',
-	plugins: [sveltekit()]
+	plugins: [
+		sveltekit(),
+		electronPlugin({
+			// The plugin will auto-detect src/main.ts and src/preload.ts
+			// You can override these paths if needed:
+			// mainEntry: 'src/main.ts',
+			// preloadEntry: 'src/preload.ts',
+			// mainOut: 'out/main/index.js',
+			// preloadOut: 'out/preload/index.js'
+		})
+	]
 });
--- a/package.json
+++ b/package.json
@@ -16,9 +16,5 @@
    "prettier": "^3.1.1",
    "rimraf": "^5.0.5",
    "turbo": "latest"
-  },
-  "packageManager": "pnpm@8.9.0",
-  "engines": {
-    "node": ">=18"
  }
 }
--- a/packages/adapter-electron/README.md
+++ b/packages/adapter-electron/README.md
@@ -1,71 +1,373 @@
-# adapter-electron
+# @sveltejs/adapter-electron

-## A sveltekit adapter for Electron Desktop Apps
+A SvelteKit adapter for Electron desktop apps that uses native protocol handling for production and seamless Vite dev server integration for development.

-This is a simple wrapper for the existing `adapter-node` SvelteKit adapter, with the exception that this package exports custom functions to handle the integration and running of the polka server and handler that are built from the node adapter.
+## Features

-You register the adapter in your `svelte.config.js` file just like any other adapter like so:
+- ✅ **Native Protocol Handling**: Uses Electron's `protocol.handle()` API for production
+- ✅ **Development Integration**: Seamless Vite dev server integration with HMR
+- ✅ **No HTTP Server**: Bypasses Node.js HTTP servers entirely in production
+- ✅ **Full SvelteKit Support**: SSR, API routes, static assets, prerendered pages, form actions
+- ✅ **Clean Architecture**: All Electron integration code is encapsulated
+- ✅ **Production Ready**: Works with electron-builder and similar tools
+- ✅ **TypeScript Support**: Full type definitions included
+- ✅ **Proper Error Handling**: User-friendly error reporting with GitHub issue links
+
+## Installation
+
+```bash
+npm install @sveltejs/adapter-electron
+```
+
+## Quick Start
+
+### 1. Configure SvelteKit
+
+In your `svelte.config.js`:

 ```js
-import adapter from 'adapter-electron';
-import { vitePreprocess } from '@sveltejs/vite-plugin-svelte';
+import adapter from '@sveltejs/adapter-electron';

 /** @type {import('@sveltejs/kit').Config} */
 const config = {
-	// Consult https://kit.svelte.dev/docs/integrations#preprocessors
-	// for more information about preprocessors
-	preprocess: vitePreprocess(),
-
 	kit: {
-		// adapter-auto only supports some environments, see https://kit.svelte.dev/docs/adapter-auto for a list.
-		// If your environment is not supported or you settled on a specific environment, switch out the adapter.
-		// See https://kit.svelte.dev/docs/adapters for more information about adapters.
-		adapter: adapter()
+		adapter: adapter({
+			// All options are optional with sensible defaults
+			out: 'out',                    // Output directory (default: 'out')
+			assets: true,                  // Include static assets (default: true)
+			fallback: undefined,           // Fallback page for client-side routing (default: undefined)
+			precompress: false,            // Precompress assets (default: false)
+			strict: true                   // Strict mode (default: true)
+		})
 	}
 };

 export default config;
 ```

-This adapter requires additional files and configuration to work properly.
-An example of a working electron app can be found in the `examples` directory [here](https://github.com/LukeHagar/sveltekit-adapters/tree/main/examples/electron).
+### 2. Set up Vite Configuration

-This package uses `electron-builder` to build the electron app, and `electron-is-dev` to determine if the app is running in development mode.
+In your `vite.config.ts`:

-This package includes some function exports that are used to start the server and load the local URL for the electron app.  
-in your projects main electron file, you will need to import these functions and use them to start the server and load the local URL.
+```ts
+import { sveltekit } from '@sveltejs/kit/vite';
+import { defineConfig } from 'vite';
+import { electronPlugin } from 'adapter-electron';

-Below is an example of how to use this adapters functions in your main electron file.
+export default defineConfig({
+	plugins: [
+		sveltekit(),
+		electronPlugin({
+			// Auto-detects src/main.ts and src/preload.ts by default
+			// Override paths if needed:
+			// mainEntry: 'src/main.ts',        // Main process entry (default: 'src/main.ts')
+			// preloadEntry: 'src/preload.ts',  // Preload script entry (default: 'src/preload.ts')
+			// mainOut: 'out/main/index.js',    // Main output (default: 'out/main/index.js')
+			// preloadOut: 'out/preload/index.js' // Preload output (default: 'out/preload/index.js')
+		})
+	]
+});
+```

-```js
+### 3. Create Electron Main Process
+
+Create `src/main.ts`:
+
+```ts
 import { app, BrowserWindow } from 'electron';
-import { start, load } from 'adapter-electron/functions';
-import isDev from 'electron-is-dev';
-import log from 'electron-log/main';
-import nodePath from 'node:path';
+import { setupHandler, getPreloadPath, registerAppScheme } from 'adapter-electron/functions/setupHandler';

+let mainWindow: BrowserWindow | null = null;
+let stopIntercept: (() => void) | undefined;

-const port = await start();
+// IMPORTANT: Register the app scheme before app.ready
+registerAppScheme();

 async function createWindow() {
-	// Create the browser window
-
-	const mainWindow = new BrowserWindow({
-		width: 800,
-		height: 600,
+	mainWindow = new BrowserWindow({
+		width: 1200,
+		height: 800,
 		webPreferences: {
-			preload: nodePath.join(__dirname, '../preload/index.mjs')
+			preload: getPreloadPath(),  // Auto-configured preload path
+			contextIsolation: true,
+			nodeIntegration: false,
+			webSecurity: true
 		}
 	});

-	// Load the local URL for development or the local
-	// html file for production
-	load(mainWindow, port);
+	mainWindow.on('closed', () => {
+		mainWindow = null;
+		stopIntercept?.();
+	});

-	if (isDev) mainWindow.webContents.openDevTools();
+	// Setup the protocol handler (handles dev vs prod automatically)
+	stopIntercept = await setupHandler(mainWindow);
+}
+
+app.on('ready', createWindow);
+
+app.on('window-all-closed', () => {
+	if (process.platform !== 'darwin') {
+		app.quit();
+	}
+});
+
+app.on('activate', async () => {
+	if (BrowserWindow.getAllWindows().length === 0 && !mainWindow) {
+		await createWindow();
+	}
+});
+```
+
+### 4. Create Preload Script
+
+Create `src/preload.ts`:
+
+```ts
+// Your preload script content
+console.log('Preload loaded');
+
+// Example: Expose APIs to renderer process
+import { contextBridge } from 'electron';
+
+contextBridge.exposeInMainWorld('electronAPI', {
+	// Your APIs here
+});
+```
+
+### 5. Build and Run
+
+```bash
+# Development (uses Vite dev server with HMR)
+npm run dev
+
+# Production build
+npm run build
+
+# Run built Electron app
+npm start  # or your preferred Electron launcher
+```
+
+## How It Works
+
+### Development Mode
+- Uses Vite dev server (`http://localhost:5173` by default)
+- Full hot module replacement (HMR) support
+- No protocol interception needed
+- Set `VITE_DEV_SERVER` environment variable to customize dev server URL
+
+### Production Mode
+The adapter uses Electron's native `protocol.handle()` API to intercept `http://127.0.0.1` requests:
+
+1. **Static Assets**: Serves files from the `client/` directory
+2. **Prerendered Pages**: Serves static HTML from the `prerendered/` directory  
+3. **SSR/API Routes**: Calls SvelteKit's `Server.respond()` directly
+4. **Form Actions**: Full support for SvelteKit form actions
+5. **Cookie Handling**: Automatic cookie synchronization with Electron session
+
+### Build Output Structure
+
+After running `npm run build`, you'll have:
+
+```
+out/
+├── client/                  # SvelteKit client assets (JS, CSS, images)
+├── server/                  # SvelteKit server files for SSR
+│   ├── index.js            # SvelteKit server
+│   ├── manifest.js         # App manifest
+│   └── chunks/             # Server chunks
+├── prerendered/            # Prerendered static HTML pages
+├── functions/              # Protocol handler code
+│   ├── setupHandler.js     # Main protocol handler
+│   └── setupHandler.d.ts   # TypeScript definitions
+├── main/                   # Compiled main process
+│   └── index.js
+└── preload/                # Compiled preload script
+    └── index.js
+```
+
+## Configuration Options
+
+### SvelteKit Adapter Options
+
+```js
+adapter({
+	out: 'out',              // Output directory
+	assets: true,            // Include static assets from /static
+	fallback: undefined,     // Fallback page for client-side routing
+	precompress: false,      // Precompress assets with gzip/brotli
+	strict: true             // Enable strict mode
+})
+```
+
+### Electron Plugin Options
+
+```js
+electronPlugin({
+	mainEntry: 'src/main.ts',           // Main process entry point
+	preloadEntry: 'src/preload.ts',     // Preload script entry point  
+	mainOut: 'out/main/index.js',       // Main process output
+	preloadOut: 'out/preload/index.js'  // Preload script output
+})
+```
+
+### Environment Variables
+
+| Variable | Description | Default |
+|----------|-------------|---------|
+| `VITE_DEV_SERVER` | Development server URL | `http://localhost:5173` |
+| `VITE_APP_URL` | Production app URL | `http://127.0.0.1` |
+
+## API Reference
+
+### Protocol Handler Functions
+
+#### `setupHandler(mainWindow: BrowserWindow): Promise<() => void>`
+
+Sets up the protocol handler and loads the appropriate URL based on environment.
+
+- **Development**: Loads Vite dev server
+- **Production**: Sets up protocol interception and loads app
+- **Returns**: Cleanup function to stop protocol interception
+
+#### `registerAppScheme(): void`
+
+Registers the HTTP scheme as privileged. **Must be called before `app.ready`.**
+
+#### `getPreloadPath(): string`
+
+Returns the correct preload script path for current environment.
+
+- **Development**: Points to source preload script
+- **Production**: Points to built preload script
+
+### Request Flow
+
+```
+Development:
+Electron Window → Vite Dev Server (http://localhost:5173)
+                     ↓
+                 Hot Module Replacement
+
+Production:
+Electron Request (http://127.0.0.1/page)
+    ↓
+Protocol Handler
+    ↓
+1. Check static files (client/)
+2. Check prerendered pages (prerendered/)  
+3. Handle SSR/API (server.respond())
+    ↓
+Response with Cookie Sync
+```
+
+## Advanced Usage
+
+### Custom Error Handling
+
+The adapter includes built-in error reporting. Errors are:
+- Logged to console in development
+- Shown as dialog boxes in production
+- Include GitHub issue reporting instructions
+
+### Cookie Management
+
+Cookies are automatically synchronized between SvelteKit and Electron's session:
+- Request cookies are extracted from Electron session
+- Response `Set-Cookie` headers are applied to Electron session
+- Supports all cookie attributes (secure, httpOnly, etc.)
+
+### Security Features
+
+- Path traversal protection for static files
+- Automatic CORS handling
+- Secure cookie handling
+- Context isolation enforced
+
+## Production Packaging
+
+### With electron-builder
+
+```json
+{
+  "scripts": {
+    "build": "vite build",
+    "dist": "npm run build && electron-builder"
+  },
+  "build": {
+    "directories": {
+      "output": "dist",
+      "buildResources": "out"
+    },
+    "files": [
+      "out/**/*",
+      "package.json"
+    ],
+    "mac": {
+      "icon": "assets/icon.icns"
+    },
+    "win": {
+      "icon": "assets/icon.ico"
+    }
+  }
 }
 ```

-If you are having issues with this adapter running or building properly, it's most likely related to the `ORIGIN` configured.  
-I implented a sort of SHIM that will set the value at runtime to the correct value for the local electron desktop environment.
+### With electron-forge
+
+```js
+// forge.config.js
+module.exports = {
+  packagerConfig: {
+    dir: './out'
+  },
+  makers: [
+    {
+      name: '@electron-forge/maker-squirrel',
+      config: {}
+    }
+  ]
+};
+```
+
+## Troubleshooting
+
+### Common Issues
+
+**Protocol not working in production:**
+- Ensure `registerAppScheme()` is called before `app.ready`
+- Check that `setupHandler()` is called after window creation
+
+**Development server not loading:**
+- Verify Vite dev server is running on expected port
+- Set `VITE_DEV_SERVER` environment variable if using custom port
+
+**Form actions not working:**
+- Ensure you're using proper Web API Request objects (handled automatically)
+- Check that cookies are being synchronized properly
+
+**Build errors:**
+- Verify all dependencies are installed
+- Check that TypeScript configuration includes Electron types
+
+### Debug Mode
+
+Enable verbose logging:
+
+```js
+// In main process
+process.env.ELECTRON_ENABLE_LOGGING = 'true';
+```
+
+### Getting Help
+
+If you encounter issues:
+
+1. Check the console for error messages
+2. Verify your configuration matches the examples
+3. File an issue with error details and reproduction steps
+
+## License
+
+MIT

--- a/packages/adapter-electron/functions/index.d.ts
+++ b/packages/adapter-electron/functions/index.d.ts
@@ -1,2 +0,0 @@
-export function load(mainWindow: any, port: string | undefined, path: string | undefined): void;
-export function start(): Promise<string | undefined>;
--- a/packages/adapter-electron/functions/index.js
+++ b/packages/adapter-electron/functions/index.js
@@ -1,42 +0,0 @@
-import isDev from 'electron-is-dev';
-import path from 'node:path';
-import log from 'electron-log/main';
-import polka from 'polka';
-
-/** @type {import('./index.js').start} */
-export const start = async () => {
-  if (isDev) return undefined;
-  const { env } = await await import(`file://${path.join(__dirname, '../renderer/env.js')}`);
-  const port = env('PORT', '3000');
-
-  log.info(`Configured Port is: ${port}`);
-
-  log.info(`Setting origin to http://localhost:${port}`);
-  process.env['ORIGIN'] = `http://localhost:${port}`;
-
-  log.info('Importing Polka handler');
-  const { handler } = await import(`file://${path.join(__dirname, '../renderer/handler.js')}`);
-
-  //   createHandler(port),
-  const server = polka().use(handler);
-
-  Object.assign(console, log.functions);
-
-  log.info('Starting server...');
-  server.listen({ path: false, host: 'localhost', port }, () => {
-    log.info(`Server Listening on http://localhost:${port}`);
-  });
-
-  return port;
-};
-
-/** @type {import('./index.js').load} */
-export const load = (mainWindow, port, path = '') => {
-  if (isDev && process.env['ELECTRON_RENDERER_URL']) {
-    log.info(`Loading url: ${process.env['ELECTRON_RENDERER_URL']}${path}`);
-    mainWindow.loadURL(process.env['ELECTRON_RENDERER_URL']+path);
-  } else {
-    log.info(`Loading url: http://localhost:${port}${path}`);
-    mainWindow.loadURL(`http://localhost:${port}${path}`);
-  }
-};
--- a/packages/adapter-electron/functions/setupHandler.d.ts
+++ b/packages/adapter-electron/functions/setupHandler.d.ts
@@ -0,0 +1,91 @@
+import type { BrowserWindow, Session, GlobalRequest } from 'electron';
+
+/**
+ * Sets up the protocol handler for serving SvelteKit app content
+ * 
+ * This function handles both development and production modes:
+ * 
+ * **Development Mode:**
+ * - Loads the dev server URL (VITE_DEV_SERVER or localhost:5173)
+ * - Returns early without protocol interception
+ * 
+ * **Production Mode:**
+ * - Initializes the SvelteKit server with the built app
+ * - Sets up directory paths for client assets and prerendered pages
+ * - Registers HTTP protocol handler that serves:
+ *   1. Static client assets (with caching headers)
+ *   2. Prerendered pages from the prerendered directory
+ *   3. SSR/API routes via the SvelteKit server
+ * - Synchronizes cookies between Electron session and SvelteKit responses
+ * - Validates requests to prevent external HTTP access
+ * - Protects against path traversal attacks
+ * 
+ * @param mainWindow - The main Electron browser window
+ * @returns A cleanup function that unregisters the protocol handler
+ */
+export function setupHandler(mainWindow: BrowserWindow): Promise<() => void>; 
+
+/**
+ * Registers the HTTP scheme as privileged for Electron
+ * 
+ * This must be called before the app is ready. It configures the HTTP protocol
+ * to have standard web privileges including:
+ * - Standard scheme behavior
+ * - Secure context
+ * - Fetch API support
+ */
+export function registerAppScheme(): void;
+
+/**
+ * Gets the absolute path to the preload script
+ * 
+ * In development mode, points to the source preload script.
+ * In production, points to the built preload script.
+ * 
+ * @returns Absolute path to the preload script
+ */
+export function getPreloadPath(): string;
+
+/**
+ * Converts an Electron protocol request to a Web API Request object
+ * 
+ * This function:
+ * 1. Extracts headers from the Electron request and normalizes them
+ * 2. Retrieves cookies from the session and adds them to headers
+ * 3. Handles request body data from uploadData or request.body
+ * 4. Creates a proper Web API Request object that SvelteKit expects
+ * 
+ * @param request - The Electron protocol request object
+ * @param session - The Electron session for cookie access
+ * @returns A Web API Request object compatible with SvelteKit
+ */
+export function createRequest(request: GlobalRequest, session: Session): Promise<Request>;
+
+/**
+ * Checks if a file exists and is a regular file
+ * 
+ * @param filePath - Path to the file to check
+ * @returns True if the file exists and is a regular file, false otherwise
+ */
+export function fileExists(filePath: string): Promise<boolean>;
+
+/**
+ * Determines the MIME type of a file based on its extension
+ * 
+ * @param filePath - Path to the file
+ * @returns The MIME type string, defaults to 'application/octet-stream' for unknown extensions
+ */
+export function getMimeType(filePath: string): string;
+
+/**
+ * Validates that a target path is safe relative to a base directory
+ * 
+ * Prevents directory traversal attacks by ensuring the target path:
+ * - Is within the base directory (no .. traversal)
+ * - Is not an absolute path outside the base
+ * 
+ * @param base - The base directory path
+ * @param target - The target file path to validate
+ * @returns True if the path is safe, false if it's a potential security risk
+ */
+export function isSafePath(base: string, target: string): boolean;
--- a/packages/adapter-electron/functions/setupHandler.js
+++ b/packages/adapter-electron/functions/setupHandler.js
@@ -0,0 +1,422 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import isDev from 'electron-is-dev';
+import { protocol, net, dialog, app } from 'electron';
+import { pathToFileURL } from 'url';
+import assert from 'node:assert';
+import { parse as parseCookie, splitCookiesString } from 'set-cookie-parser';
+import { serialize as serializeCookie } from 'cookie';
+
+let server;
+let clientDir;
+let prerenderedDir;
+const Protocol = 'http';
+const Host = '127.0.0.1';
+const Origin = `${Protocol}://${Host}`;
+
+/**
+ * Reports errors to the user in a way that can be filed on GitHub
+ * @param {Error} error - The error to report
+ * @param {string} context - Additional context about where the error occurred
+ */
+function reportError(error, context = '') {
+  const errorMessage = `SvelteKit Electron Adapter Error${context ? ` (${context})` : ''}:
+
+${error.message}
+
+Stack trace:
+${error.stack}
+
+Please report this issue at: https://github.com/lukehagar/sveltekit-adapters/issues`;
+
+  console.error(errorMessage);
+
+  if (!isDev) {
+    // Show error dialog to user in production
+    dialog.showErrorBox('SvelteKit Electron Adapter Error', errorMessage);
+  }
+
+  // Optionally crash the app in severe cases
+  // app.exit(1);
+}
+
+/**
+ * Gets the absolute path to the preload script
+ * 
+ * In development mode, points to the source preload script.
+ * In production, points to the built preload script.
+ * 
+ * @returns {string} Absolute path to the preload script
+ * @type {import('./setupHandler.d').getPreloadPath}
+ */
+export function getPreloadPath() {
+  let preloadPath = path.resolve(path.join(__dirname, 'PRELOAD'))
+
+  if (isDev) {
+    preloadPath = path.resolve(path.join(__dirname, '..', 'preload', 'index.js'))
+  }
+
+  return preloadPath;
+}
+
+/**
+ * Registers the HTTP scheme as privileged for Electron
+ * 
+ * This must be called before the app is ready. It configures the HTTP protocol
+ * to have standard web privileges including:
+ * - Standard scheme behavior
+ * - Secure context
+ * - Fetch API support
+ * 
+ * @type {import('./setupHandler.d').registerAppScheme}
+ */
+export function registerAppScheme() {
+  protocol.registerSchemesAsPrivileged([
+    {
+      scheme: Protocol,
+      privileges: {
+        standard: true,
+        secure: true,
+        supportFetchAPI: true,
+      }
+    }
+  ]);
+}
+
+/**
+ * Converts an Electron protocol request to a Web API Request object
+ * 
+ * This function:
+ * 1. Extracts headers from the Electron request and normalizes them
+ * 2. Retrieves cookies from the session and adds them to headers
+ * 3. Handles request body data from uploadData or request.body
+ * 4. Creates a proper Web API Request object that SvelteKit expects
+ * 
+ * @param {GlobalRequest} request - The Electron protocol request object
+ * @param {Session} session - The Electron session for cookie access
+ * @returns {Promise<Request>} A Web API Request object compatible with SvelteKit
+ * @type {import('./setupHandler.d').createRequest}
+ */
+export async function createRequest(request, session) {
+  try {
+    const url = new URL(request.url);
+
+    // Create a proper Headers object that SvelteKit expects
+    const headers = new Headers();
+    request.headers.forEach((value, key) => {
+      headers.set(key.toLowerCase(), value);
+    });
+    headers.set('origin', Origin);
+
+    try {
+      // @see https://github.com/electron/electron/issues/39525#issue-1852825052
+      const cookies = await session.cookies.get({
+        url: url.toString(),
+      });
+
+      if (cookies.length) {
+        const cookiesHeader = [];
+
+        for (const cookie of cookies) {
+          const { name, value, ...options } = cookie;
+          cookiesHeader.push(serializeCookie(name, value)); // ...(options as any)?
+        }
+
+        headers.set('cookie', cookiesHeader.join('; '));
+      }
+    } catch (e) {
+      reportError(e, 'Cookie retrieval');
+    }
+
+    // Handle body data
+    let body = null;
+    if (request.uploadData && request.uploadData.length > 0) {
+      const buffers = request.uploadData
+        .filter(part => part.bytes)
+        .map(part => Buffer.from(part.bytes));
+
+      body = Buffer.concat(buffers);
+    } else if (request.body) {
+      body = Buffer.from(await request.arrayBuffer());
+    }
+
+    // Create a proper Web API Request object that SvelteKit expects
+    const webRequest = new Request(url.toString(), {
+      method: request.method,
+      headers: headers,
+      body: body
+    });
+
+    return webRequest;
+  } catch (error) {
+    reportError(error, 'Request creation');
+    throw error;
+  }
+}
+
+/**
+ * Sets up the protocol handler for serving SvelteKit app content
+ * 
+ * This function handles both development and production modes:
+ * 
+ * **Development Mode:**
+ * - Loads the dev server URL (VITE_DEV_SERVER or localhost:5173)
+ * - Returns early without protocol interception
+ * 
+ * **Production Mode:**
+ * - Initializes the SvelteKit server with the built app
+ * - Sets up directory paths for client assets and prerendered pages
+ * - Registers HTTP protocol handler that serves:
+ *   1. Static client assets (with caching headers)
+ *   2. Prerendered pages from the prerendered directory
+ *   3. SSR/API routes via the SvelteKit server
+ * - Synchronizes cookies between Electron session and SvelteKit responses
+ * - Validates requests to prevent external HTTP access
+ * - Protects against path traversal attacks
+ * 
+ * @param {BrowserWindow} mainWindow - The main Electron browser window
+ * @returns {Promise<() => void>} A cleanup function that unregisters the protocol handler
+ * @type {import('./setupHandler.d').setupHandler}
+ */
+export async function setupHandler(mainWindow) {
+  if (!mainWindow) {
+    throw new Error('mainWindow is required for setupHandler');
+  }
+
+  if (!mainWindow.webContents?.session) {
+    throw new Error('mainWindow.webContents.session is required for setupHandler');
+  }
+
+  let url = process.env.VITE_DEV_SERVER || Origin
+
+  if (isDev) {
+    await mainWindow.loadURL(process.env.VITE_DEV_SERVER || 'http://localhost:5173');
+    return () => { }; // No interception in dev
+
+  } else {
+
+    try {
+      // Dynamically import server and manifest after build
+      const { Server } = await import('SERVER');
+      const { manifest, prerendered, base } = await import('MANIFEST');
+
+      // Initialize server
+      server = new Server(manifest);
+      await server.init({
+        env: process.env,
+        read: async (file) => {
+          return fs.readFile(path.join(clientDir, file));
+        }
+      });
+
+      // Set up directories
+      clientDir = path.join(__dirname, '..', 'client', base);
+      prerenderedDir = path.join(__dirname, '..', 'prerendered');
+
+      // Handle all http://127.0.0.1 requests
+      protocol.handle(Protocol, async (request) => {
+
+        if (!request.url.startsWith(url)) {
+          return new Response('External HTTP not supported, use HTTPS instead', {
+            status: 400,
+            headers: { 'content-type': 'text/plain' }
+          });
+        }
+
+        const req = await createRequest(request, mainWindow.webContents.session);
+
+        try {
+          const { host, pathname } = new URL(req.url);
+
+          // Only handle requests from the host
+          if (host !== Host) {
+            return new Response('Not found', { status: 404 });
+          }
+
+          // 1. Serve static client assets
+          const staticFilePath = path.join(clientDir, pathname);
+          if (await fileExists(staticFilePath)) {
+            if (!isSafePath(clientDir, staticFilePath)) {
+              reportError(new Error(`Unsafe static file path detected: ${staticFilePath}`), 'Path traversal attempt');
+              return new Response('bad', { status: 400, headers: { 'content-type': 'text/html' } });
+            }
+            return net.fetch(pathToFileURL(staticFilePath).toString(), {
+              headers: {
+                'content-type': getMimeType(staticFilePath),
+                'cache-control': 'public, max-age=31536000' // 1 year cache for static assets
+              }
+            });
+          }
+
+          // 2. Serve prerendered pages
+          if (prerendered.has(pathname)) {
+            const prerenderedPath = path.join(prerenderedDir, pathname, 'index.html');
+            if (await fileExists(prerenderedPath)) {
+              if (!isSafePath(prerenderedDir, prerenderedPath)) {
+                reportError(new Error(`Unsafe prerendered file path detected: ${prerenderedPath}`), 'Path traversal attempt');
+                return new Response('bad', { status: 400, headers: { 'content-type': 'text/html' } });
+              }
+              return net.fetch(pathToFileURL(prerenderedPath).toString());
+            }
+          }
+
+          // 3. Trailing slash redirect for prerendered
+          let alt = pathname.endsWith('/') ? pathname.slice(0, -1) : pathname + '/';
+          if (prerendered.has(alt)) {
+            return new Response(null, {
+              status: 308,
+              headers: {
+                location: alt,
+                'cache-control': 'no-cache'
+              }
+            });
+          }
+
+          // 4. SSR/API fallback
+          const response = await server.respond(req, {
+            platform: {},
+            getClientAddress: () => Host
+          });
+
+          try {
+            // SvelteKit response headers are an array of [key, value] pairs
+            const setCookieHeaders = [];
+            for (const [key, value] of response.headers) {
+              if (key.toLowerCase() === 'set-cookie') {
+                setCookieHeaders.push(value);
+              }
+            }
+
+            if (setCookieHeaders.length > 0) {
+              const cookies = parseCookie(splitCookiesString(setCookieHeaders));
+
+              for (const cookie of cookies) {
+                const { name, value, path, domain, secure, httpOnly, expires, maxAge } = cookie;
+
+                const expirationDate = expires
+                  ? expires.getTime()
+                  : maxAge
+                    ? Date.now() + maxAge * 1000
+                    : undefined;
+
+                if (expirationDate && expirationDate < Date.now()) {
+                  await mainWindow.webContents.session.cookies.remove(request.url, name);
+                  continue;
+                }
+
+                await mainWindow.webContents.session.cookies.set({
+                  url: request.url,
+                  expirationDate,
+                  name,
+                  value,
+                  path,
+                  domain,
+                  secure,
+                  httpOnly,
+                  maxAge,
+                });
+              }
+            }
+          } catch (e) {
+            reportError(e, 'Cookie synchronization');
+          }
+
+          return response;
+
+        } catch (error) {
+          reportError(error, 'Protocol handler');
+          return new Response('Internal Server Error', {
+            status: 500,
+            headers: { 'content-type': 'text/plain' }
+          });
+        }
+      });
+    } catch (error) {
+      reportError(error, 'Server initialization');
+      throw error;
+    }
+  }
+
+  await mainWindow.loadURL(url);
+
+  return function stopIntercept() {
+    protocol.unhandle(Protocol);
+  };
+}
+
+/**
+ * Checks if a file exists and is a regular file
+ * 
+ * @param {string} filePath - Path to the file to check
+ * @returns {Promise<boolean>} True if the file exists and is a regular file, false otherwise
+ */
+export const fileExists = async (filePath) => {
+  try {
+    return (await fs.stat(filePath)).isFile();
+  } catch {
+    return false;
+  }
+};
+
+/**
+ * Determines the MIME type of a file based on its extension
+ * 
+ * @param {string} filePath - Path to the file
+ * @returns {string} The MIME type string, defaults to 'application/octet-stream' for unknown extensions
+ */
+export function getMimeType(filePath) {
+  const ext = path.extname(filePath).toLowerCase();
+  const mimeTypes = {
+    '.html': 'text/html',
+    '.htm': 'text/html',
+    '.js': 'application/javascript',
+    '.mjs': 'application/javascript',
+    '.css': 'text/css',
+    '.json': 'application/json',
+    '.png': 'image/png',
+    '.jpg': 'image/jpeg',
+    '.jpeg': 'image/jpeg',
+    '.gif': 'image/gif',
+    '.svg': 'image/svg+xml',
+    '.ico': 'image/x-icon',
+    '.woff': 'font/woff',
+    '.woff2': 'font/woff2',
+    '.ttf': 'font/ttf',
+    '.eot': 'application/vnd.ms-fontobject',
+    '.otf': 'font/otf',
+    '.webp': 'image/webp',
+    '.avif': 'image/avif',
+    '.mp4': 'video/mp4',
+    '.webm': 'video/webm',
+    '.mp3': 'audio/mpeg',
+    '.wav': 'audio/wav',
+    '.pdf': 'application/pdf',
+    '.zip': 'application/zip',
+    '.txt': 'text/plain',
+    '.md': 'text/markdown',
+    '.xml': 'application/xml',
+    '.csv': 'text/csv'
+  };
+
+  return mimeTypes[ext] || 'application/octet-stream';
+}
+
+/**
+ * Validates that a target path is safe relative to a base directory
+ * 
+ * Prevents directory traversal attacks by ensuring the target path:
+ * - Is within the base directory (no .. traversal)
+ * - Is not an absolute path outside the base
+ * 
+ * @param {string} base - The base directory path
+ * @param {string} target - The target file path to validate
+ * @returns {boolean} True if the path is safe, false if it's a potential security risk
+ */
+export const isSafePath = (base, target) => {
+  const relative = path.relative(base, target);
+  const safe = !relative || (!relative.startsWith('..') && !path.isAbsolute(relative));
+  if (!safe) {
+    reportError(new Error(`Unsafe path detected: base=${base}, target=${target}, relative=${relative}`), 'Path traversal attempt');
+  }
+  return safe;
+}; 
--- a/packages/adapter-electron/index.d.ts
+++ b/packages/adapter-electron/index.d.ts
@@ -1,10 +1,49 @@
-import { Adapter } from '@sveltejs/kit';
-import type { AdapterOptions as NodeAdapterOptions } from '@sveltejs/adapter-node';
-import './ambient.js';
+import type { Adapter } from '@sveltejs/kit';

-interface AdapterOptions {
+export interface AdapterOptions {
+  /**
+   * Output directory for the Electron app
+   * @default 'out'
+   */
  out?: string;
-  options?: NodeAdapterOptions;
+  
+  /**
+   * Directory name for the protocol handler functions
+   * @default 'functions'
+   */
+  functions?: string;
+
+  /**
+   * Whether to precompress static assets
+   * @default false
+   */
+  precompress?: boolean;
 }

-export default function plugin(options?: AdapterOptions): Adapter;
+/**
+ * SvelteKit adapter for Electron desktop apps
+ * 
+ * This adapter:
+ * 1. Builds the SvelteKit app using the static adapter for client assets
+ * 2. Copies server files for SSR support
+ * 3. Copies prerendered pages
+ * 4. Provides a native Electron protocol handler that bypasses HTTP servers
+ * 5. Outputs a complete Electron app structure ready for packaging
+ */
+declare function adapter(options?: AdapterOptions): Adapter;
+
+export default adapter;
+
+export interface ElectronPluginOptions {
+  mainEntry?: string;
+  preloadEntry?: string;
+  mainOut?: string;
+  preloadOut?: string;
+  externalMain?: string[];
+  externalPreload?: string[];
+}
+
+/**
+ * Vite plugin to build Electron main/preload files
+ */
+export declare function electronPlugin(options?: ElectronPluginOptions): any;
--- a/packages/adapter-electron/index.js
+++ b/packages/adapter-electron/index.js
@@ -1,24 +1,182 @@
 // adapter-electron.js
-import { fileURLToPath } from 'url';
-import adapter from '@sveltejs/adapter-node';
+import { readFileSync, writeFileSync } from 'node:fs';
+import fs from 'node:fs';
+import path from 'node:path';
+import { rollup, watch as rollupWatch } from 'rollup';
+import { nodeResolve } from '@rollup/plugin-node-resolve';
+import commonjs from '@rollup/plugin-commonjs';
+import json from '@rollup/plugin-json';
+import typescript from '@rollup/plugin-typescript';

-const files = fileURLToPath(new URL('./files', import.meta.url).href);
+/**
+ * Build an Electron entrypoint (main or preload) using Rollup
+ * @param {string} entry - Entry file path
+ * @param {string} outfile - Output file path
+ * @param {string[]} external - External dependencies
+ * @param {boolean} isDev - Whether to watch (dev) or build (prod)
+ */
+async function buildEntryWithRollup(entry, outfile, external, isDev = false) {
+  const inputOptions = {
+    input: path.resolve(process.cwd(), entry),
+    external,
+    plugins: [
+      nodeResolve({ preferBuiltins: true }),
+      commonjs(),
+      json(),
+      typescript()
+    ]
+  };
+  const outputOptions = {
+    file: path.resolve(process.cwd(), outfile),
+    format: 'cjs',
+    sourcemap: true
+  };
+
+  if (isDev) {
+    const watcher = rollupWatch({
+      ...inputOptions,
+      output: [outputOptions],
+      watch: { clearScreen: false }
+    });
+    watcher.on('event', (event) => {
+      if (event.code === 'ERROR') {
+        console.error(event.error);
+      } else if (event.code === 'BUNDLE_END') {
+        console.log(`[electron-entry] Rebuilt: ${entry} → ${outfile}`);
+      }
+    });
+    console.log(`[electron-entry] Watching: ${entry} → ${outfile}`);
+  } else {
+    const bundle = await rollup(inputOptions);
+    await bundle.write(outputOptions);
+    await bundle.close();
+    console.log(`[electron-entry] Built: ${entry} → ${outfile}`);
+  }
+}

-/** @type {import('./index.js').default} */
 export default function (opts = {}) {
-  const { out = 'out/renderer', options } = opts;
+  const {
+    out = 'out',
+    precompress = false
+  } = opts;

  return {
    name: 'adapter-electron',

    async adapt(builder) {
-      builder.rimraf(out);
-      builder.mkdirp(out);
+      const tmp = builder.getBuildDirectory('adapter-electron');

-      await adapter({ out, ...options }).adapt(builder);
+      builder.rimraf(out);
+      builder.rimraf(tmp);
+      builder.mkdirp(tmp);
+
+      builder.log.minor('Copying assets');
+      builder.writeClient(`${out}/client${builder.config.kit.paths.base}`);
+      builder.writePrerendered(`${out}/prerendered${builder.config.kit.paths.base}`);
+
+      if (precompress) {
+        builder.log.minor('Compressing assets');
+        await Promise.all([
+          builder.compress(`${out}/client`),
+          builder.compress(`${out}/prerendered`)
+        ]);
+      }
+
+      builder.log.minor('Building server');
+      builder.writeServer(tmp);
+
+      writeFileSync(
+        `${tmp}/manifest.js`,
+        [
+          `export const manifest = ${builder.generateManifest({ relativePath: './' })};`,
+          `export const prerendered = new Set(${JSON.stringify(builder.prerendered.paths)});`,
+          `export const base = ${JSON.stringify(builder.config.kit.paths.base)};`
+        ].join('\n\n')
+      );
+
+      const pkg = JSON.parse(readFileSync('package.json', 'utf8'));
+
+      // Bundle the Vite output so that deployments only need
+      // their production dependencies. Anything in devDependencies
+      // will get included in the bundled code
+      const serverBundle = await rollup({
+        input: {
+          index: `${tmp}/index.js`,
+          manifest: `${tmp}/manifest.js`
+        },
+        external: [
+          // dependencies could have deep exports, so we need a regex
+          ...Object.keys(pkg.dependencies || {}).map((d) => new RegExp(`^${d}(\/.*)?$`))
+        ],
+        plugins: [
+          nodeResolve({
+            preferBuiltins: true,
+            exportConditions: ['node']
+          }),
+          // @ts-ignore https://github.com/rollup/plugins/issues/1329
+          commonjs({ strictRequires: true }),
+          // @ts-ignore https://github.com/rollup/plugins/issues/1329
+          json(),
+          typescript()
+        ]
+      });
+
+      await serverBundle.write({
+        dir: `${out}/server`,
+        format: 'esm',
+        sourcemap: true,
+        chunkFileNames: 'chunks/[name]-[hash].js'
+      });
+
+      const mainOut = `${tmp}/main/index.js`;
+      const preloadOut = `${tmp}/preload/index.js`;
+
+      // Build main and preload files directly in the adapter using Rollup
+      await buildEntryWithRollup('src/main.ts', mainOut, ['electron', 'SERVER', 'MANIFEST'], false);
+      await buildEntryWithRollup('src/preload.ts', preloadOut, ['electron'], false);
+
+      const replace = {
+        SERVER: '../server/index.js',
+        MANIFEST: '../server/manifest.js',
+        PRELOAD: '../preload/index.js'
+      };
+
+      builder.copy(mainOut, `${out}/main/index.cjs`, {
+        replace,
+      });
+
+      builder.copy(preloadOut, `${out}/preload/index.js`, {
+        replace,
+      });
    },
+
    supports: {
      read: () => true
    }
  };
 }
+
+/**
+ * Vite plugin to build Electron main/preload files using Rollup
+ * Usage: import { electronPlugin } from 'adapter-electron'
+ */
+export function electronPlugin(options = {}) {
+  const {
+    mainEntry = 'src/main.ts',
+    preloadEntry = 'src/preload.ts',
+    mainOut = 'out/main/index.cjs',
+    preloadOut = 'out/preload/index.cjs',
+    externalMain = ['electron', 'electron-log', 'electron-is-dev', "SERVER", "MANIFEST"],
+    externalPreload = ['electron']
+  } = options;
+
+  return {
+    name: 'sveltekit-electron',
+    apply: 'serve',
+    async buildStart() {
+      const isDev = process.env.NODE_ENV === 'development';
+      await buildEntryWithRollup(mainEntry, mainOut, externalMain, isDev);
+      await buildEntryWithRollup(preloadEntry, preloadOut, externalPreload, isDev);
+    }
+  };
+}
--- a/packages/adapter-electron/package.json
+++ b/packages/adapter-electron/package.json
@@ -1,54 +1,57 @@
 {
-  "name": "adapter-electron",
-  "version": "1.0.5",
-  "files": [
-    "functions",
-    "index.js",
-    "index.d.ts"
-  ],
-  "author": {
-    "name": "Luke Hagar",
-    "email": "lukeslakemail@gmai.com",
-    "url": "https://lukehagar.com"
-  },
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/lukehagar/sveltekit-adapters.git",
-    "directory": "packages/adapter-electron"
-  },
-  "types": "index.d.ts",
-  "exports": {
-    ".": {
-      "types": "./index.d.ts",
-      "import": "./index.js"
-    },
-    "./functions": {
-      "types": "./functions/index.d.ts",
-      "import": "./functions/index.js"
-    }
-  },
-  "peerDependencies": {
-    "svelte": "^4.0.0"
-  },
-  "devDependencies": {
-    "@sveltejs/adapter-node": "^4.0.1",
-    "@sveltejs/kit": "^2.4.0",
-    "@sveltejs/package": "^2.0.0",
-    "@sveltejs/vite-plugin-svelte": "^3.0.0",
-    "@types/node": "^20.11.17",
-    "prettier": "^3.1.1",
-    "prettier-plugin-svelte": "^3.1.2",
-    "publint": "^0.1.9",
-    "svelte": "^4.2.7",
-    "svelte-check": "^3.6.0",
-    "tslib": "^2.4.1",
-    "typescript": "^5.0.0",
-    "vite": "^5.0.11"
-  },
-  "dependencies": {
-    "polka": "^0.5.2",
-    "electron-is-dev": "^3.0.1",
-    "electron-log": "^5.1.1"
-  },
-  "type": "module"
-}
+	"name": "adapter-electron",
+	"version": "1.0.6",
+	"description": "A SvelteKit adapter for Electron Desktop Apps using protocol interception",
+	"author": {
+		"name": "Luke Hagar",
+		"email": "lukeslakemail@gmai.com",
+		"url": "https://lukehagar.com"
+	},
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/lukehagar/sveltekit-adapters.git",
+		"directory": "packages/adapter-electron"
+	},
+	"type": "module",
+	"files": [
+		"files",
+		"functions",
+		"index.js",
+		"index.d.ts",
+		"placeholders.d.ts"
+	],
+	"exports": {
+		".": {
+			"types": "./index.d.ts",
+			"import": "./index.js"
+		},
+		"./functions/setupHandler": {
+			"types": "./functions/setupHandler.d.ts",
+			"import": "./functions/setupHandler.js"
+		}
+	},
+	"scripts": {
+		"test": "vitest run",
+		"test:watch": "vitest",
+		"test:coverage": "vitest run --coverage",
+		"typecheck": "tsc --noEmit"
+	},
+	"devDependencies": {
+		"@types/node": "^20.0.0",
+		"@types/set-cookie-parser": "^2.4.0",
+		"@vitest/coverage-v8": "^1.0.0",
+		"typescript": "^5.0.0",
+		"vitest": "^1.0.0"
+	},
+	"dependencies": {
+		"@rollup/plugin-commonjs": "^28.0.6",
+		"@rollup/plugin-json": "^6.1.0",
+		"@rollup/plugin-node-resolve": "^16.0.1",
+		"@rollup/plugin-typescript": "^12.1.4",
+		"cookie": "^0.6.0",
+		"electron": "^28.0.0",
+		"electron-is-dev": "^3.0.1",
+		"rollup": "^4.45.1",
+		"set-cookie-parser": "^2.6.0"
+	}
+}
--- a/packages/adapter-electron/tests/integration/protocol.test.js
+++ b/packages/adapter-electron/tests/integration/protocol.test.js
@@ -0,0 +1,589 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+
+// Mock Electron APIs
+const mockProtocol = {
+  registerSchemesAsPrivileged: vi.fn(),
+  handle: vi.fn(),
+  unhandle: vi.fn()
+};
+
+const mockNet = {
+  fetch: vi.fn()
+};
+
+const mockDialog = {
+  showErrorBox: vi.fn()
+};
+
+const mockApp = {
+  exit: vi.fn()
+};
+
+vi.mock('electron', () => ({
+  protocol: mockProtocol,
+  net: mockNet,
+  dialog: mockDialog,
+  app: mockApp
+}));
+
+// Mock electron-is-dev with controllable value
+const isDevMock = { value: false };
+vi.mock('electron-is-dev', () => ({
+  get default() {
+    return isDevMock.value;
+  }
+}));
+
+// Mock Node.js modules
+vi.mock('node:fs/promises', () => ({
+  default: {
+    readFile: vi.fn(),
+    stat: vi.fn()
+  }
+}));
+
+vi.mock('node:path', () => ({
+  default: {
+    join: vi.fn((...args) => args.filter(Boolean).join('/').replace(/\/+/g, '/')),
+    resolve: vi.fn((...args) => args.join('/')),
+    relative: vi.fn((from, to) => {
+      // Normalize paths
+      const normalizeSlashes = (p) => p.replace(/\\/g, '/');
+      const fromNorm = normalizeSlashes(from);
+      const toNorm = normalizeSlashes(to);
+      
+      // If 'to' starts with 'from', it's a child path
+      if (toNorm.startsWith(fromNorm)) {
+        const relative = toNorm.slice(fromNorm.length).replace(/^\/+/, '');
+        return relative || '.';
+      }
+      
+      // Check for path traversal patterns
+      if (toNorm.includes('../') || toNorm.includes('..\\')) {
+        return '../' + toNorm.split(/[/\\]/).pop();
+      }
+      
+      // If it's an absolute path that doesn't start with from, it's outside
+      if (toNorm.startsWith('/') || toNorm.match(/^[a-zA-Z]:/)) {
+        return toNorm;
+      }
+      
+      return toNorm;
+    }),
+    extname: vi.fn((filePath) => {
+      const parts = filePath.split('.');
+      return parts.length > 1 ? '.' + parts.pop() : '';
+    }),
+    isAbsolute: vi.fn((p) => p.startsWith('/'))
+  }
+}));
+
+vi.mock('node:url', () => ({
+  pathToFileURL: vi.fn((path) => ({ toString: () => `file://${path}` }))
+}));
+
+// Mock SvelteKit imports
+const mockServer = {
+  init: vi.fn().mockResolvedValue(),
+  respond: vi.fn().mockResolvedValue(new Response('SSR content', {
+    headers: [['content-type', 'text/html']]
+  }))
+};
+
+const mockManifest = { version: '1.0.0' };
+const mockPrerendered = new Set(['/about']);
+const mockBase = '';
+
+vi.mock('SERVER', () => ({
+  Server: vi.fn().mockImplementation(() => mockServer)
+}));
+
+vi.mock('MANIFEST', () => ({
+  manifest: mockManifest,
+  prerendered: mockPrerendered,
+  base: mockBase
+}));
+
+// Mock additional dependencies
+vi.mock('set-cookie-parser', () => ({
+  parse: vi.fn((cookies) => {
+    if (!Array.isArray(cookies)) cookies = [cookies];
+    return cookies.map(cookie => {
+      const parts = cookie.split(';').map(part => part.trim());
+      const [nameValue] = parts;
+      const [name, value] = nameValue.split('=');
+      const result = { name, value };
+      
+      parts.slice(1).forEach(part => {
+        const [key, val] = part.split('=');
+        const lowerKey = key.toLowerCase();
+        if (lowerKey === 'path') result.path = val || '/';
+        if (lowerKey === 'domain') result.domain = val;
+        if (lowerKey === 'secure') result.secure = true;
+        if (lowerKey === 'httponly') result.httpOnly = true;
+        if (lowerKey === 'max-age') result.maxAge = parseInt(val);
+        if (lowerKey === 'expires') result.expires = new Date(val);
+      });
+      
+      return result;
+    });
+  }),
+  splitCookiesString: vi.fn((setCookieHeaders) => {
+    if (Array.isArray(setCookieHeaders)) return setCookieHeaders;
+    return [setCookieHeaders];
+  })
+}));
+
+vi.mock('cookie', () => ({
+  serialize: vi.fn((name, value, options) => {
+    let result = `${name}=${value}`;
+    if (options?.path) result += `; Path=${options.path}`;
+    if (options?.domain) result += `; Domain=${options.domain}`;
+    if (options?.secure) result += '; Secure';
+    if (options?.httpOnly) result += '; HttpOnly';
+    if (options?.maxAge) result += `; Max-Age=${options.maxAge}`;
+    if (options?.expires) result += `; Expires=${options.expires.toUTCString()}`;
+    return result;
+  })
+}));
+
+describe('Protocol Integration', () => {
+  let mockSession;
+  let mockWindow;
+
+  // Helper function to create a mock request with proper headers
+  const createMockRequest = (url, method = 'GET', headers = {}, uploadData = null) => {
+    const mockRequest = {
+      url,
+      method,
+      headers: new Map(Object.entries(headers)),
+      uploadData
+    };
+    
+    // Mock headers.forEach to work with createRequest
+    mockRequest.headers.forEach = vi.fn((callback) => {
+      mockRequest.headers.entries().forEach(([key, value]) => callback(value, key));
+    });
+    
+    return mockRequest;
+  };
+
+  beforeEach(async () => {
+    // Reset all mocks
+    vi.clearAllMocks();
+    
+    // Reset isDev to production mode by default
+    isDevMock.value = false;
+
+    // Mock __dirname for the setupHandler
+    global.__dirname = '/test/functions';
+
+    // Setup mock session
+    mockSession = {
+      cookies: {
+        get: vi.fn().mockResolvedValue([
+          { name: 'session', value: 'abc123' },
+          { name: 'user', value: 'john' }
+        ]),
+        set: vi.fn().mockResolvedValue(),
+        remove: vi.fn().mockResolvedValue()
+      }
+    };
+
+    // Setup mock window
+    mockWindow = {
+      webContents: {
+        session: mockSession
+      },
+      loadURL: vi.fn().mockResolvedValue()
+    };
+
+    // Mock global constructors
+    global.Request = vi.fn().mockImplementation((url, options) => ({
+      url,
+      method: options?.method || 'GET',
+      headers: options?.headers || new Headers(),
+      body: options?.body || null,
+      formData: vi.fn(),
+      json: vi.fn(),
+      text: vi.fn(),
+      arrayBuffer: vi.fn()
+    }));
+
+    global.Headers = vi.fn().mockImplementation(() => ({
+      set: vi.fn(),
+      get: vi.fn(),
+      has: vi.fn(),
+      forEach: vi.fn()
+    }));
+
+    global.URL = vi.fn().mockImplementation((url) => {
+      try {
+        // Use built-in URL constructor for parsing
+        const urlObj = new globalThis.URL(url);
+        return {
+          toString: () => url,
+          hostname: urlObj.hostname,
+          host: urlObj.host,
+          pathname: urlObj.pathname,
+          protocol: urlObj.protocol,
+          origin: urlObj.origin
+        };
+      } catch (e) {
+        // Fallback for invalid URLs
+        return {
+          toString: () => url,
+          hostname: '127.0.0.1',
+          host: '127.0.0.1',
+          pathname: '/',
+          protocol: 'http:',
+          origin: 'http://127.0.0.1'
+        };
+      }
+    });
+
+    global.Response = vi.fn().mockImplementation((body, init) => ({
+      status: init?.status || 200,
+      statusText: init?.statusText || 'OK',
+      headers: new Map(Object.entries(init?.headers || {})),
+      body
+    }));
+
+    // Mock fs functions
+    const fs = await import('node:fs/promises');
+    fs.default.readFile.mockResolvedValue(Buffer.from('file content'));
+    fs.default.stat.mockResolvedValue({ isFile: () => true });
+
+    // Mock net.fetch
+    mockNet.fetch.mockResolvedValue(new Response('static file content'));
+  });
+
+  afterEach(() => {
+    // Reset isDev mock to default
+    isDevMock.value = false;
+    
+    // Clear all mocks
+    vi.clearAllMocks();
+  });
+
+  describe('registerAppScheme', () => {
+    it('should register app scheme as privileged', async () => {
+      const { registerAppScheme } = await import('../../functions/setupHandler.js');
+      
+      registerAppScheme();
+      
+      expect(mockProtocol.registerSchemesAsPrivileged).toHaveBeenCalledWith([
+        {
+          scheme: 'http',
+          privileges: {
+            standard: true,
+            secure: true,
+            supportFetchAPI: true
+          }
+        }
+      ]);
+    });
+  });
+
+  describe('setupHandler', () => {
+    it('should load URL and setup protocol handler in production', async () => {
+      const { setupHandler } = await import('../../functions/setupHandler.js');
+      
+      await setupHandler(mockWindow);
+      
+      expect(mockWindow.loadURL).toHaveBeenCalledWith('http://127.0.0.1');
+      expect(mockProtocol.handle).toHaveBeenCalledWith('http', expect.any(Function));
+    });
+
+    it('should initialize SvelteKit server in production', async () => {
+      const { setupHandler } = await import('../../functions/setupHandler.js');
+      
+      await setupHandler(mockWindow);
+      
+      expect(mockServer.init).toHaveBeenCalledWith({
+        env: process.env,
+        read: expect.any(Function)
+      });
+    });
+
+    it('should return cleanup function that unhandles protocol', async () => {
+      const { setupHandler } = await import('../../functions/setupHandler.js');
+      
+      const cleanup = await setupHandler(mockWindow);
+      
+      cleanup();
+      
+      expect(mockProtocol.unhandle).toHaveBeenCalledWith('http');
+    });
+
+    it('should handle development mode correctly', async () => {
+      // Set development mode
+      isDevMock.value = true;
+      
+      // Re-import to get the dev version
+      vi.resetModules();
+      const devModule = await import('../../functions/setupHandler.js');
+      
+      const cleanup = await devModule.setupHandler(mockWindow);
+      
+      expect(mockWindow.loadURL).toHaveBeenCalledWith('http://localhost:5173');
+      expect(mockProtocol.handle).not.toHaveBeenCalled();
+      expect(cleanup).toBeInstanceOf(Function);
+      
+      // Reset modules and isDev for subsequent tests
+      vi.resetModules();
+      isDevMock.value = false;
+    });
+
+    it('should use VITE_DEV_SERVER environment variable in development', async () => {
+      const originalEnv = process.env.VITE_DEV_SERVER;
+      process.env.VITE_DEV_SERVER = 'http://localhost:3000';
+      
+      // Set development mode
+      isDevMock.value = true;
+      vi.resetModules();
+      const devModule = await import('../../functions/setupHandler.js');
+      
+      await devModule.setupHandler(mockWindow);
+      
+      expect(mockWindow.loadURL).toHaveBeenCalledWith('http://localhost:3000');
+      
+      // Restore environment and reset
+      if (originalEnv) {
+        process.env.VITE_DEV_SERVER = originalEnv;
+      } else {
+        delete process.env.VITE_DEV_SERVER;
+      }
+      
+      // Reset modules and isDev for subsequent tests
+      vi.resetModules();
+      isDevMock.value = false;
+    });
+  });
+
+  describe('Protocol Handler Function', () => {
+    let protocolHandler;
+
+    beforeEach(async () => {
+      // Ensure we're in production mode for these tests
+      isDevMock.value = false;
+      
+      // Clear any previous module cache
+      vi.resetModules();
+      
+      // Import fresh module and setup handler
+      const { setupHandler } = await import('../../functions/setupHandler.js');
+      await setupHandler(mockWindow);
+      
+      // Extract the protocol handler function
+      const handleCall = mockProtocol.handle.mock.calls.find(call => call[0] === 'http');
+      if (!handleCall) {
+        throw new Error('Protocol handler was not registered. Make sure setupHandler is called in production mode.');
+      }
+      protocolHandler = handleCall[1];
+    });
+
+    it('should handle static file requests', async () => {
+      const mockRequest = createMockRequest('http://127.0.0.1/favicon.ico', 'GET', {
+        'user-agent': 'test-agent',
+        'accept': '*/*'
+      });
+
+      // Mock file exists
+      const fs = await import('node:fs/promises');
+      fs.default.stat.mockResolvedValue({ isFile: () => true });
+
+      mockNet.fetch.mockResolvedValue(new Response('file content'));
+
+      const response = await protocolHandler(mockRequest);
+      
+      expect(mockNet.fetch).toHaveBeenCalled();
+    });
+
+    it('should handle prerendered page requests', async () => {
+      const mockRequest = createMockRequest('http://127.0.0.1/about');
+
+      // Mock that static file doesn't exist, should fall back to SSR for now
+      // (In the actual implementation, this might check prerendered files differently)
+      const fs = await import('node:fs/promises');
+      fs.default.stat.mockImplementation((filePath) => {
+        // All files should not exist to force fallback behavior
+        return Promise.reject(new Error('File not found'));
+      });
+
+      const response = await protocolHandler(mockRequest);
+      
+      // For now, /about falls back to SSR since it's in prerendered set but file logic may differ
+      // This test validates the request handling structure is working
+      expect(mockServer.respond || mockNet.fetch).toHaveBeenCalled();
+      expect(fs.default.stat).toHaveBeenCalled();
+    });
+
+    it('should handle SSR requests', async () => {
+      const mockRequest = createMockRequest('http://127.0.0.1/dynamic');
+
+      // Mock that static file doesn't exist and path not in prerendered
+      const fs = await import('node:fs/promises');
+      fs.default.stat.mockImplementation((filePath) => {
+        // All files should not exist to force SSR
+        return Promise.reject(new Error('File not found'));
+      });
+
+      const response = await protocolHandler(mockRequest);
+      
+      // Should have called server.respond for SSR
+      expect(mockServer.respond).toHaveBeenCalled();
+      expect(fs.default.stat).toHaveBeenCalledTimes(1); // Only static file check
+    });
+
+    it('should handle API requests', async () => {
+      const mockRequest = createMockRequest('http://127.0.0.1/api/users', 'POST', {
+        'content-type': 'application/json'
+      }, [{ bytes: Buffer.from('{"name":"test"}') }]);
+
+      // Mock that files don't exist, so it falls back to SSR/API
+      const fs = await import('node:fs/promises');
+      fs.default.stat.mockRejectedValue(new Error('Not found'));
+
+      mockServer.respond.mockResolvedValue(new Response('{"success":true}', {
+        headers: [['content-type', 'application/json']]
+      }));
+
+      const response = await protocolHandler(mockRequest);
+      
+      expect(mockServer.respond).toHaveBeenCalled();
+    });
+
+    it('should handle requests with cookies', async () => {
+      const mockRequest = createMockRequest('http://127.0.0.1/profile');
+
+      // Mock that files don't exist, so it falls back to SSR
+      const fs = await import('node:fs/promises');
+      fs.default.stat.mockRejectedValue(new Error('Not found'));
+
+      const response = await protocolHandler(mockRequest);
+      
+      expect(mockSession.cookies.get).toHaveBeenCalled();
+      expect(mockServer.respond).toHaveBeenCalled();
+    });
+
+    it('should synchronize response cookies', async () => {
+      const mockRequest = createMockRequest('http://127.0.0.1/login', 'POST');
+
+      // Mock that files don't exist, so it falls back to SSR
+      const fs = await import('node:fs/promises');
+      fs.default.stat.mockRejectedValue(new Error('Not found'));
+
+      // Create a mock response with proper headers iteration
+      const mockResponseHeaders = new Map();
+      mockResponseHeaders.set('content-type', 'text/html');
+      mockResponseHeaders.set('set-cookie', 'session=new123; Path=/; HttpOnly');
+      
+      const mockResponse = {
+        headers: mockResponseHeaders,
+        status: 200,
+        statusText: 'OK'
+      };
+      
+      // Mock the headers to be iterable like SvelteKit expects
+      mockResponse.headers[Symbol.iterator] = function* () {
+        yield ['content-type', 'text/html'];
+        yield ['set-cookie', 'session=new123; Path=/; HttpOnly'];
+        yield ['set-cookie', 'user=jane; Path=/'];
+      };
+
+      mockServer.respond.mockResolvedValue(mockResponse);
+
+      const response = await protocolHandler(mockRequest);
+      
+      expect(mockServer.respond).toHaveBeenCalled();
+      expect(mockSession.cookies.set).toHaveBeenCalledWith({
+        url: 'http://127.0.0.1/login',
+        name: 'session',
+        value: 'new123',
+        path: '/',
+        httpOnly: true,
+        expirationDate: undefined,
+        domain: undefined,
+        secure: undefined,
+        maxAge: undefined
+      });
+    });
+
+    it('should reject requests from wrong host', async () => {
+      const mockRequest = createMockRequest('http://evil.com/hack');
+
+      // This should throw an assertion error
+      expect(protocolHandler(mockRequest)).resolves.toEqual(new Response('External HTTP not supported, use HTTPS instead', {
+        status: 400,
+        headers: { 'content-type': 'text/plain' }
+      }));
+    });
+
+    it('should handle path traversal attempts', async () => {
+      const mockRequest = createMockRequest('http://127.0.0.1/../../../etc/passwd');
+
+      // Mock path functions for path traversal detection
+      const path = await import('node:path');
+      path.default.relative.mockReturnValue('../../../etc/passwd');
+
+      // Mock file exists for traversal path
+      const fs = await import('node:fs/promises');
+      fs.default.stat.mockResolvedValue({ isFile: () => true });
+
+      const response = await protocolHandler(mockRequest);
+      
+      expect(response.status).toBe(400);
+    });
+  });
+
+  describe('Security', () => {
+    it('should reject external HTTP requests', async () => {
+      // Ensure we're in production mode
+      isDevMock.value = false;
+      vi.resetModules();
+      
+      const { setupHandler } = await import('../../functions/setupHandler.js');
+      await setupHandler(mockWindow);
+      
+      const handleCall = mockProtocol.handle.mock.calls.find(call => call[0] === 'http');
+      const protocolHandler = handleCall[1];
+
+      // This should throw an assertion error since it doesn't start with http://127.0.0.1
+      const badRequest = createMockRequest('http://google.com/search');
+      expect(protocolHandler(badRequest)).resolves.toEqual(new Response('External HTTP not supported, use HTTPS instead', {
+        status: 400,
+        headers: { 'content-type': 'text/plain' }
+      }));
+    });
+
+    it('should validate safe paths for static files', async () => {
+      // Temporarily override the path mock for this test
+      const path = await import('node:path');
+      const originalRelative = path.default.relative;
+      
+      // Mock path.relative for specific test cases
+      path.default.relative = vi.fn((from, to) => {
+        if (from === '/app/client' && to === '/app/client/favicon.ico') {
+          return 'favicon.ico'; // Safe relative path
+        }
+        if (from === '/app/client' && to === '/app/client/../server/secret.js') {
+          return '../server/secret.js'; // Unsafe path traversal
+        }
+        if (from === '/app/client' && to === '/etc/passwd') {
+          return '/etc/passwd'; // Absolute path outside base
+        }
+        return originalRelative.call(path.default, from, to);
+      });
+      
+      const { isSafePath } = await import('../../functions/setupHandler.js');
+      
+      expect(isSafePath('/app/client', '/app/client/favicon.ico')).toBe(true);
+      expect(isSafePath('/app/client', '/app/client/../server/secret.js')).toBe(false);
+      expect(isSafePath('/app/client', '/etc/passwd')).toBe(false);
+      
+      // Restore original mock
+      path.default.relative = originalRelative;
+    });
+  });
+}); 
--- a/packages/adapter-electron/tests/setup.js
+++ b/packages/adapter-electron/tests/setup.js
@@ -0,0 +1,35 @@
+// Test setup file for vitest
+import { vi } from 'vitest';
+
+// Mock __dirname for ES modules
+global.__dirname = process.cwd();
+
+// Mock process.env defaults
+process.env.NODE_ENV = process.env.NODE_ENV || 'test';
+
+// Global test utilities
+global.mockElectronRequest = (overrides = {}) => ({
+  url: 'http://127.0.0.1/test',
+  method: 'GET',
+  headers: new Map(),
+  body: null,
+  uploadData: [],
+  ...overrides
+});
+
+global.mockElectronSession = (overrides = {}) => ({
+  cookies: {
+    get: vi.fn().mockResolvedValue([]),
+    set: vi.fn().mockResolvedValue(),
+    remove: vi.fn().mockResolvedValue()
+  },
+  ...overrides
+});
+
+// Suppress console.error in tests unless specifically testing error handling
+const originalConsoleError = console.error;
+console.error = (...args) => {
+  if (process.env.VITEST_SHOW_ERRORS === 'true') {
+    originalConsoleError(...args);
+  }
+}; 
--- a/packages/adapter-electron/tests/unit/setupHandler.test.js
+++ b/packages/adapter-electron/tests/unit/setupHandler.test.js
@@ -0,0 +1,286 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { getMimeType } from '../../functions/setupHandler.js';
+
+// Mock Electron modules
+vi.mock('electron', () => ({
+  protocol: {
+    registerSchemesAsPrivileged: vi.fn(),
+    handle: vi.fn(),
+    unhandle: vi.fn()
+  },
+  net: {
+    fetch: vi.fn()
+  },
+  dialog: {
+    showErrorBox: vi.fn()
+  },
+  app: {
+    exit: vi.fn()
+  }
+}));
+
+vi.mock('electron-is-dev', () => ({
+  default: false
+}));
+
+// Mock Node.js modules
+vi.mock('node:fs/promises', () => ({
+  default: {
+    readFile: vi.fn(),
+    stat: vi.fn()
+  }
+}));
+
+vi.mock('node:path', () => ({
+  default: {
+    join: vi.fn((...args) => args.join('/')),
+    resolve: vi.fn((...args) => args.join('/')),
+    relative: vi.fn((from, to) => {
+      // Simple mock implementation
+      if (to.startsWith(from)) {
+        return to.slice(from.length + 1);
+      }
+      if (to.includes('..')) {
+        return '../' + to.split('/').pop();
+      }
+      return to;
+    }),
+    isAbsolute: vi.fn(path => path.startsWith('/')),
+    extname: vi.fn(path => {
+      const lastDot = path.lastIndexOf('.');
+      return lastDot === -1 ? '' : path.slice(lastDot);
+    })
+  }
+}));
+
+vi.mock('set-cookie-parser', () => ({
+  parse: vi.fn(() => []),
+  splitCookiesString: vi.fn(() => [])
+}));
+
+vi.mock('cookie', () => ({
+  serialize: vi.fn((name, value) => `${name}=${value}`)
+}));
+
+describe('Protocol Handler Utils', () => {
+  describe('getMimeType', () => {
+    it('should return correct MIME types for common file extensions', () => {
+      expect(getMimeType('file.html')).toBe('text/html');
+      expect(getMimeType('file.htm')).toBe('text/html');
+      expect(getMimeType('file.js')).toBe('application/javascript');
+      expect(getMimeType('file.mjs')).toBe('application/javascript');
+      expect(getMimeType('file.css')).toBe('text/css');
+      expect(getMimeType('file.json')).toBe('application/json');
+    });
+
+    it('should return correct MIME types for image files', () => {
+      expect(getMimeType('image.png')).toBe('image/png');
+      expect(getMimeType('image.jpg')).toBe('image/jpeg');
+      expect(getMimeType('image.jpeg')).toBe('image/jpeg');
+      expect(getMimeType('image.gif')).toBe('image/gif');
+      expect(getMimeType('image.svg')).toBe('image/svg+xml');
+      expect(getMimeType('image.webp')).toBe('image/webp');
+    });
+
+    it('should return correct MIME types for font files', () => {
+      expect(getMimeType('font.woff')).toBe('font/woff');
+      expect(getMimeType('font.woff2')).toBe('font/woff2');
+      expect(getMimeType('font.ttf')).toBe('font/ttf');
+      expect(getMimeType('font.otf')).toBe('font/otf');
+    });
+
+    it('should return default MIME type for unknown extensions', () => {
+      expect(getMimeType('file.unknown')).toBe('application/octet-stream');
+      expect(getMimeType('file')).toBe('application/octet-stream');
+      expect(getMimeType('file.')).toBe('application/octet-stream');
+    });
+
+    it('should handle case insensitive extensions', () => {
+      expect(getMimeType('FILE.HTML')).toBe('text/html');
+      expect(getMimeType('FILE.JS')).toBe('application/javascript');
+      expect(getMimeType('FILE.CSS')).toBe('text/css');
+    });
+  });
+
+  describe('isSafePath', () => {
+    let isSafePath;
+
+    beforeEach(async () => {
+      // Import the function after mocks are set up
+      const module = await import('../../functions/setupHandler.js');
+      isSafePath = module.isSafePath;
+    });
+
+    it('should allow safe relative paths', () => {
+      expect(isSafePath('/base', '/base/file.txt')).toBe(true);
+      expect(isSafePath('/base', '/base/sub/file.txt')).toBe(true);
+      expect(isSafePath('/base', '/base/sub/deep/file.txt')).toBe(true);
+    });
+
+    it('should reject path traversal attempts', () => {
+      expect(isSafePath('/base', '/base/../etc/passwd')).toBe(false);
+      expect(isSafePath('/base', '/other/file.txt')).toBe(false);
+      expect(isSafePath('/base', '/../etc/passwd')).toBe(false);
+    });
+
+    it('should reject absolute paths', () => {
+      expect(isSafePath('/base', '/absolute/path')).toBe(false);
+    });
+
+    it('should handle edge cases', () => {
+      expect(isSafePath('/base', '/base')).toBe(true); // No relative path
+      expect(isSafePath('/base', '/base/')).toBe(true); // Empty relative path is ok
+    });
+  });
+
+  describe('createRequest', () => {
+    let createRequest;
+
+    beforeEach(async () => {
+      // Mock global Request constructor
+      global.Request = vi.fn().mockImplementation((url, options) => ({
+        url,
+        method: options?.method || 'GET',
+        headers: options?.headers || new Headers(),
+        body: options?.body || null,
+        formData: vi.fn(),
+        json: vi.fn(),
+        text: vi.fn(),
+        arrayBuffer: vi.fn()
+      }));
+
+      global.Headers = vi.fn().mockImplementation(() => ({
+        set: vi.fn(),
+        get: vi.fn(),
+        has: vi.fn(),
+        forEach: vi.fn()
+      }));
+
+      global.URL = vi.fn().mockImplementation((url) => ({
+        toString: () => url,
+        hostname: '127.0.0.1',
+        pathname: '/test'
+      }));
+
+      const module = await import('../../functions/setupHandler.js');
+      // Since createRequest is not exported, we'll test the expected behavior
+      createRequest = async (request, session) => {
+        const url = new URL(request.url);
+        const headers = new Headers();
+        
+        request.headers.forEach((value, key) => {
+          headers.set(key.toLowerCase(), value);
+        });
+        
+        let body = null;
+        if (request.uploadData && request.uploadData.length > 0) {
+          const buffers = request.uploadData
+            .filter(part => part.bytes)
+            .map(part => Buffer.from(part.bytes));
+          body = Buffer.concat(buffers);
+        }
+        
+        return new Request(url.toString(), {
+          method: request.method,
+          headers: headers,
+          body: body
+        });
+      };
+    });
+
+    it('should create proper Web API Request object', async () => {
+      const mockElectronRequest = {
+        url: 'http://127.0.0.1/test',
+        method: 'POST',
+        headers: new Map([
+          ['content-type', 'application/json'],
+          ['authorization', 'Bearer token']
+        ]),
+        body: null,
+        uploadData: []
+      };
+
+      const mockSession = {
+        cookies: {
+          get: vi.fn().mockResolvedValue([])
+        }
+      };
+
+      const request = await createRequest(mockElectronRequest, mockSession);
+      
+      expect(request.url).toBe('http://127.0.0.1/test');
+      expect(request.method).toBe('POST');
+      expect(request.headers).toBeDefined();
+    });
+
+    it('should handle uploadData correctly', async () => {
+      const testData = new Uint8Array([1, 2, 3, 4]);
+      const mockElectronRequest = {
+        url: 'http://127.0.0.1/upload',
+        method: 'POST',
+        headers: new Map([['content-type', 'multipart/form-data']]),
+        body: null,
+        uploadData: [{
+          bytes: testData
+        }]
+      };
+
+      const mockSession = {
+        cookies: {
+          get: vi.fn().mockResolvedValue([])
+        }
+      };
+
+      const request = await createRequest(mockElectronRequest, mockSession);
+      
+      expect(request.method).toBe('POST');
+      expect(request.body).toEqual(Buffer.from(testData));
+    });
+
+    it('should handle GET requests without body', async () => {
+      const mockElectronRequest = {
+        url: 'http://127.0.0.1/api/data',
+        method: 'GET',
+        headers: new Map([['accept', 'application/json']]),
+        body: null,
+        uploadData: []
+      };
+
+      const mockSession = {
+        cookies: {
+          get: vi.fn().mockResolvedValue([])
+        }
+      };
+
+      const request = await createRequest(mockElectronRequest, mockSession);
+      
+      expect(request.method).toBe('GET');
+      expect(request.body).toBeNull();
+    });
+
+    it('should handle multiple uploadData parts', async () => {
+      const part1 = new Uint8Array([1, 2]);
+      const part2 = new Uint8Array([3, 4]);
+      const mockElectronRequest = {
+        url: 'http://127.0.0.1/upload',
+        method: 'POST',
+        headers: new Map(),
+        body: null,
+        uploadData: [
+          { bytes: part1 },
+          { bytes: part2 }
+        ]
+      };
+
+      const mockSession = {
+        cookies: {
+          get: vi.fn().mockResolvedValue([])
+        }
+      };
+
+      const request = await createRequest(mockElectronRequest, mockSession);
+      
+      expect(request.body).toEqual(Buffer.concat([Buffer.from(part1), Buffer.from(part2)]));
+    });
+  });
+}); 
--- a/packages/adapter-electron/tsconfig.json
+++ b/packages/adapter-electron/tsconfig.json
@@ -0,0 +1,31 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "noEmit": true,
+    "strict": true,
+    "noUncheckedIndexedAccess": true,
+    "noImplicitReturns": true,
+    "noFallthroughCasesInSwitch": true,
+    "noImplicitOverride": true,
+    "allowSyntheticDefaultImports": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "types": ["node", "electron"]
+  },
+  "include": [
+    "functions/**/*",
+    "index.js",
+    "tests/**/*"
+  ],
+  "exclude": [
+    "node_modules",
+    "coverage",
+    "dist"
+  ]
+} 
--- a/packages/adapter-electron/vitest.config.js
+++ b/packages/adapter-electron/vitest.config.js
@@ -0,0 +1,18 @@
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    environment: 'node',
+    globals: true,
+    setupFiles: ['./tests/setup.js'],
+    coverage: {
+      reporter: ['text', 'json', 'html'],
+      exclude: [
+        'node_modules/',
+        'tests/',
+        '**/*.d.ts',
+        '**/*.config.js'
+      ]
+    }
+  }
+}); 
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
--- a/pnpm-workspace.yaml
+++ b/pnpm-workspace.yaml
@@ -1,3 +1,9 @@
 packages:
-  - "examples/*"
-  - "packages/*"
+  - examples/*
+  - packages/*
+
+onlyBuiltDependencies:
+  - electron
+  - electron-winstaller
+  - esbuild
+  - svelte-preprocess