edges-svelte 2.2.1 → 3.0.1

package/README.md

@@ -2,15 +2,16 @@
 
 ### A blazing-fast, extremely lightweight and SSR-friendly store for SvelteKit.
 
-**EdgeS** brings seamless, per-request state management to Svelte apps — fully reactive, server-aware, and serialization-safe by default.
+**EdgeS** brings seamless, per-request state management to Svelte apps.
 
-No context boilerplate. No hydration headaches. Just drop-in SSR-compatible state primitives with built-in support for client-side reactivity and server-side isolation.
+No context boilerplate. No hydration headaches.
 
-- 🔄 Unified state for server and client
-- 🧠 Persistent per-request memory via `AsyncLocalStorage`
-- 💧 Tiny API
-- 💥 Instant serialization without magic
-- 🧩 Dependency injection, zero runtime overhead
+- Persistent per-request memory via `AsyncLocalStorage`
+- Tiny API
+- Instant serialization without magic
+- Dependency injection, zero runtime overhead
+
+EdgeS is built to prevent state leaks. Its primary goal is to keep server-side state safely isolated per request while providing a clean developer experience with presenters, stores, and automatic client updates when fresh state arrives from the server. It is intentionally one-way sync from server to client and does not aim to provide full two-way state synchronization between client and server.
 
 > Designed for **SvelteKit**.
 
@@ -77,8 +78,8 @@ const myStore = createStore('MyUniqueStoreName', ({ createState, createDerivedSt
 <!-- Will update the state -->
 ```
 
-- 💡 All stores created inside `createStore` use unique keys automatically and are request-scoped
-- 🛡️ Fully SSR-safe — stores are isolated per request and serialized automatically
+- All stores created inside `createStore` use unique keys automatically and are request-scoped
+- Fully SSR-safe — stores are isolated per request and serialized automatically
 
 ---
 
@@ -158,6 +159,22 @@ const useUserStore = withDeps(({ user, createState }) => {
 });
 ```
 
+For provider-to-provider dependencies, inject provider functions lazily:
+
+```ts
+const useAuth = createPresenter('AuthPresenter', () => ({ isLoggedIn: true }));
+
+const useHeader = createPresenter(
+	'HeaderPresenter',
+	({ useAuth }) => ({
+		canShowProfile: () => useAuth().isLoggedIn
+	}),
+	{ useAuth }
+);
+```
+
+Avoid injecting resolved provider instances. In development, edges throws a fail-fast error for eager provider injection and for circular dependency chains like `A -> B -> A`.
+
 ---
 
 ## createPresenter
@@ -279,48 +296,9 @@ You can skip specifying a unique key and pass the factory as the first argument
 
 ---
 
-## State Compression
-
-### Method 1: Via Plugin (Recommended) ✨
+## State Serialization
 
-```typescript
-// vite.config.ts - Zero config compression!
-import { sveltekit } from '@sveltejs/kit/vite';
-import { defineConfig } from 'vite';
-import { edgesPlugin } from 'edges-svelte/plugin';
-
-export default defineConfig({
-	plugins: [
-		sveltekit(),
-		edgesPlugin({
-			compression: {
-				enabled: true, // Enable compression
-				threshold: 2048 // Compress states > 2KB
-			},
-			silentChromeDevtools: true // Optional: silence devtools requests
-		})
-	]
-});
-
-// That's it! No need to touch hooks.server.ts
-```
-
-### Method 2: Manual Setup (For advanced use cases)
-
-```typescript
-// hooks.server.ts - If you need custom control
-import { edgesHandle } from 'edges-svelte/server';
-
-export const handle = edgesHandle(({ serialize, edgesEvent, resolve }) => {
-	return resolve(edgesEvent, {
-		transformPageChunk: ({ html }) =>
-			serialize(html, {
-				compress: true, // Enable compression
-				compressionThreshold: 2048 // Compress states > 2KB
-			})
-	});
-});
-```
+EdgeS serializes SSR state as plain script payloads. Transport-level compression should be handled by your HTTP stack (gzip/brotli) instead of application-level compression in this package.
 
 ---
 

package/dist/client/NavigationStateObserver.svelte

@@ -0,0 +1,9 @@
+<script lang="ts">
+	import { page } from '$app/state';
+	import { applyEdgesFromPayload } from './NavigationSync.svelte.js';
+
+	$effect(() => {
+		applyEdgesFromPayload(page.data);
+		applyEdgesFromPayload(page.form);
+	});
+</script>

package/dist/client/NavigationStateObserver.svelte.d.ts

@@ -0,0 +1,3 @@
+declare const NavigationStateObserver: import("svelte").Component<Record<string, never>, {}, "">;
+type NavigationStateObserver = ReturnType<typeof NavigationStateObserver>;
+export default NavigationStateObserver;

package/dist/client/NavigationSync.svelte.d.ts

@@ -1,3 +1,9 @@
 export declare function registerStateUpdate(key: string, callback: (value: unknown) => void): void;
 export declare function unregisterStateUpdate(key: string): void;
 export declare function processEdgesState(edgesState: Record<string, unknown>): void;
+export declare function applyEdgesFromPayload(payload: unknown): void;
+declare global {
+    interface Window {
+        __EDGES_NAVIGATION_SYNC_MOUNTED__?: boolean;
+    }
+}

package/dist/client/NavigationSync.svelte.js

@@ -1,15 +1,28 @@
 import { browser } from '../utils/environment.js';
+import { batch } from '../utils/batch.js';
 const stateUpdateCallbacks = new Map();
 const UNDEFINED_MARKER = '__EDGES_UNDEFINED__';
 const NULL_MARKER = '__EDGES_NULL__';
-const safeReviver = (key, value) => {
+const BIGINT_MARKER = '__EDGES_BIGINT__';
+const EDGES_STATE_FIELD = '__edges_state__';
+const EDGES_REV_FIELD = '__edges_rev__';
+let lastAppliedRevision = 0;
+const decodeEdgesValue = (value) => {
     if (value && typeof value === 'object') {
-        if (UNDEFINED_MARKER in value) {
+        if (UNDEFINED_MARKER in value)
             return undefined;
-        }
-        if (NULL_MARKER in value) {
+        if (NULL_MARKER in value)
             return null;
+        if (BIGINT_MARKER in value)
+            return BigInt(String(value[BIGINT_MARKER]));
+        if (Array.isArray(value)) {
+            return value.map((item) => decodeEdgesValue(item));
+        }
+        const decoded = {};
+        for (const [key, nested] of Object.entries(value)) {
+            decoded[key] = decodeEdgesValue(nested);
         }
+        return decoded;
     }
     return value;
 };
@@ -22,142 +35,62 @@ export function unregisterStateUpdate(key) {
     stateUpdateCallbacks.delete(key);
 }
 export function processEdgesState(edgesState) {
-    if (!window.__SAFE_SSR_STATE__) {
-        window.__SAFE_SSR_STATE__ = new Map();
-    }
-    for (const [key, value] of Object.entries(edgesState)) {
-        let processedValue = value;
-        if (typeof value === 'string') {
-            try {
-                processedValue = JSON.parse(value, safeReviver);
+    const store = window.__SAFE_SSR_STATE__ ?? new Map();
+    window.__SAFE_SSR_STATE__ = store;
+    batch(() => {
+        for (const [key, value] of Object.entries(edgesState)) {
+            let processedValue = decodeEdgesValue(value);
+            if (typeof value === 'string') {
+                try {
+                    processedValue = decodeEdgesValue(JSON.parse(value));
+                }
+                catch {
+                    /*  do nothing  */
+                }
             }
-            catch {
-                // If not JSON then use without handling
+            store.set(key, processedValue);
+            const callback = stateUpdateCallbacks.get(key);
+            if (callback) {
+                callback(processedValue);
             }
         }
-        window.__SAFE_SSR_STATE__.set(key, processedValue);
-        const callback = stateUpdateCallbacks.get(key);
-        if (callback) {
-            callback(processedValue);
-        }
+    });
+}
+export function applyEdgesFromPayload(payload) {
+    if (!payload || typeof payload !== 'object')
+        return;
+    const data = payload;
+    const rawState = data[EDGES_STATE_FIELD];
+    if (!rawState || typeof rawState !== 'object')
+        return;
+    const revision = Number(data[EDGES_REV_FIELD] ?? 0);
+    if (Number.isFinite(revision) && revision > 0) {
+        if (revision <= lastAppliedRevision)
+            return;
+        lastAppliedRevision = revision;
     }
+    processEdgesState(rawState);
 }
 if (browser) {
-    const originalFetch = window.fetch;
-    const parseHeaders = (headers) => {
-        const parsedHeaders = {};
-        switch (true) {
-            case headers instanceof Headers:
-                headers.forEach((value, key) => {
-                    parsedHeaders[key] = value;
-                });
-                return parsedHeaders;
-            case headers && typeof headers === 'object':
-                Object.entries(headers).forEach(([key, value]) => {
-                    parsedHeaders[key] = value;
-                });
-                return parsedHeaders;
-            default:
-                return parsedHeaders;
-        }
-    };
-    window.fetch = async function (...args) {
-        const [input, init] = args;
-        let reqInfo = { url: '', headers: {} };
-        if (typeof input === 'string') {
-            reqInfo = { url: input, headers: parseHeaders(init?.headers) };
-        }
-        else if (input instanceof Request) {
-            reqInfo = { url: input.url, headers: parseHeaders(input.headers) };
-        }
-        else if (input instanceof URL) {
-            reqInfo = { url: input.href, headers: parseHeaders(init?.headers) };
-        }
-        const isSvelteKitRequest = init.__sveltekit_fetch__ || reqInfo.headers['x-sveltekit-action'] || reqInfo.url.includes('__data.json');
-        const response = await originalFetch.apply(this, args);
-        if (!isSvelteKitRequest) {
-            return response;
-        }
-        if (!response.headers.get('content-type')?.includes('application/json')) {
-            return response;
-        }
-        const interceptEdgesStateFromResponse = (response) => {
-            if (!response.body)
-                return response;
-            if (init?.method === 'POST') {
-                const originalText = response.text.bind(response);
-                response.text = async function () {
-                    const text = await originalText();
-                    if (text.includes('__edges_state__')) {
-                        try {
-                            const parsed = JSON.parse(text);
-                            if (parsed.__edges_state__) {
-                                processEdgesState(parsed.__edges_state__);
-                            }
-                        }
-                        catch {
-                            // ignore parsing errors
-                        }
-                    }
-                    return text;
-                };
-            }
-            const originalGetReader = response.body.getReader.bind(response.body);
-            response.body.getReader = function (opts) {
-                const reader = originalGetReader(opts);
-                if (!('read' in reader))
-                    return reader;
-                const originalRead = reader.read.bind(reader);
-                const decoder = new TextDecoder();
-                let buffer = '';
-                let found = false;
-                let depth = 0;
-                let capture = '';
-                reader.read = async function () {
-                    const result = await originalRead();
-                    if (result.done || found)
-                        return result;
-                    buffer += decoder.decode(result.value, { stream: true });
-                    const idx = buffer.indexOf('"__edges_state__"');
-                    if (idx !== -1) {
-                        const braceStart = buffer.indexOf('{', idx);
-                        if (braceStart !== -1) {
-                            for (let i = braceStart; i < buffer.length; i++) {
-                                const ch = buffer[i];
-                                if (ch === '{') {
-                                    if (depth++ === 0)
-                                        capture = '';
-                                }
-                                if (depth > 0)
-                                    capture += ch;
-                                if (ch === '}') {
-                                    depth--;
-                                    if (depth === 0) {
-                                        try {
-                                            const parsed = JSON.parse(capture);
-                                            processEdgesState(parsed);
-                                            found = true;
-                                        }
-                                        catch {
-                                            // waiting for next iteration
-                                        }
-                                        break;
-                                    }
-                                }
-                            }
-                        }
-                        const MAX_BUFFER = Math.max(8192, capture.length * 2);
-                        if (buffer.length > MAX_BUFFER)
-                            buffer = buffer.slice(-MAX_BUFFER / 2);
-                    }
-                    return result;
-                };
-                return reader;
-            };
-            return response;
-        };
-        return interceptEdgesStateFromResponse(response);
-    };
+    if (!window.__EDGES_NAVIGATION_SYNC_MOUNTED__) {
+        window.__EDGES_NAVIGATION_SYNC_MOUNTED__ = true;
+        void Promise.all([import('svelte'), import('./NavigationStateObserver.svelte')])
+            .then(([svelte, module]) => {
+            const target = document.body || document.documentElement;
+            const host = document.createElement('div');
+            host.setAttribute('data-edges-navigation-sync', '1');
+            host.style.display = 'none';
+            target.appendChild(host);
+            svelte.mount(module.default, { target: host });
+            window.addEventListener('beforeunload', () => {
+                host.remove();
+                window.__EDGES_NAVIGATION_SYNC_MOUNTED__ = false;
+            }, { once: true });
+        })
+            .catch(() => {
+            window.__EDGES_NAVIGATION_SYNC_MOUNTED__ = false;
+        });
+    }
     if (typeof MutationObserver !== 'undefined') {
         const observer = new MutationObserver((mutations) => {
             for (const mutation of mutations) {
@@ -167,13 +100,16 @@ if (browser) {
                             const text = node.textContent || '';
                             if (text.includes('__SAFE_SSR_STATE__') && text.includes('__EDGES_REVIVER__')) {
                                 queueMicrotask(() => {
-                                    if (window.__SAFE_SSR_STATE__) {
-                                        for (const [key, value] of window.__SAFE_SSR_STATE__) {
-                                            const callback = stateUpdateCallbacks.get(key);
-                                            if (callback) {
-                                                callback(value);
+                                    const store = window.__SAFE_SSR_STATE__;
+                                    if (store) {
+                                        batch(() => {
+                                            for (const [key, value] of store) {
+                                                const callback = stateUpdateCallbacks.get(key);
+                                                if (callback) {
+                                                    callback(value);
+                                                }
                                             }
-                                        }
+                                        });
                                     }
                                 });
                             }

package/dist/context/Context.d.ts

@@ -7,6 +7,9 @@ export interface ContextData {
         providers?: Map<string, unknown>;
         providersAutoKeyCache?: WeakMap<(...args: unknown[]) => unknown, string>;
         providersAutoKeyCounters?: Map<string, number>;
+        providersConstructionStack?: string[];
+        edgesDirtyKeys?: Set<string>;
+        edgesRevision?: number;
     } & App.ContextDataExtended;
 }
 declare class RequestContextManager {

package/dist/index.d.ts

@@ -1,3 +1,4 @@
 export * from './provider/Provider.js';
 export { batch, transaction } from './utils/batch.js';
+export { __withEdgesUniversalLoad } from './server/ServerSync.js';
 export type * from './types.js';

package/dist/index.js

@@ -1,2 +1,3 @@
 export * from './provider/Provider.js';
 export { batch, transaction } from './utils/batch.js';
+export { __withEdgesUniversalLoad } from './server/ServerSync.js';

package/dist/plugin/EdgesAutoHandlePlugin.d.ts

@@ -1,10 +1,8 @@
 import type { Plugin } from 'vite';
 export interface EdgesPluginOptions {
-    compression?: {
-        enabled?: boolean;
-        threshold?: number;
-    };
     silentChromeDevtools?: boolean;
+    syncFromServer?: boolean;
+    syncTransformMode?: 'ast' | 'regex' | 'hybrid';
 }
 /**
  * Creates a factory for the edges plugin with a custom package name and server path.

package/dist/plugin/EdgesAutoHandlePlugin.js

@@ -1,3 +1,4 @@
+import * as ts from 'typescript';
 /**
  * Creates a factory for the edges plugin with a custom package name and server path.
  *
@@ -16,16 +17,197 @@
  * ```
  */
 export function createEdgesPluginFactory(packageName, serverPath) {
-    // Compile regex patterns once per factory (performance optimization)
     const MANUAL_IMPORT_PATTERN = new RegExp(`from\\s+['"](?:${packageName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}/server|\\$lib/server)['"]`, 'g');
-    // Match "export const handle" with optional type annotation (e.g., ": Handle")
     const HANDLE_EXPORT_PATTERN = /export\s+const\s+handle\s*(?::\s*\w+\s*)?=/;
+    const LOAD_EXPORT_PATTERN = /export\s+const\s+load\s*(?::\s*[^=]+)?=/;
+    const ACTIONS_EXPORT_PATTERN = /export\s+const\s+actions\s*(?::\s*[^=]+)?=/;
+    const SERVER_ROUTE_PATTERN = /[\\/]\+((page|layout)\.server)\.(t|j)s$/;
+    const UNIVERSAL_ROUTE_PATTERN = /[\\/]\+((page|layout))\.(t|j)s$/;
+    const SYNC_MARKER = "void '__EDGES_SYNC_WRAPPED__';";
+    const AST_SERVER_LOAD_ALIAS = '__edgesWrappedServerLoad';
+    const AST_ACTIONS_ALIAS = '__edgesWrappedActions';
+    const AST_UNIVERSAL_LOAD_ALIAS = '__edgesWrappedUniversalLoad';
+    const applyEdits = (sourceCode, edits) => {
+        if (edits.length === 0)
+            return sourceCode;
+        const sorted = edits.sort((a, b) => b.start - a.start);
+        let result = sourceCode;
+        for (const edit of sorted) {
+            result = result.slice(0, edit.start) + edit.text + result.slice(edit.end);
+        }
+        return result;
+    };
     return function edgesPlugin(options) {
-        const { compression = {}, silentChromeDevtools = true } = options || {};
+        const { silentChromeDevtools = true, syncFromServer = true, syncTransformMode = 'hybrid' } = options || {};
+        const findImportInsertPosition = (sourceCode) => {
+            const importRegex = /(?:^|\n)((?:import|export)\s+(?:type\s+)?(?:\{[^}]*\}|\*|\w+)(?:\s+from)?\s+['"][^'"]+['"];?)/gm;
+            let lastMatch = null;
+            let match;
+            while ((match = importRegex.exec(sourceCode)) !== null) {
+                lastMatch = match;
+            }
+            if (!lastMatch) {
+                return 0;
+            }
+            return lastMatch.index + lastMatch[0].length;
+        };
+        const ensureSyncImport = (sourceCode, importLine) => {
+            if (sourceCode.includes('__EDGES_SYNC_WRAPPED__'))
+                return sourceCode;
+            const insertPos = findImportInsertPosition(sourceCode);
+            const beforeImports = sourceCode.slice(0, insertPos);
+            const afterImports = sourceCode.slice(insertPos);
+            return `${beforeImports}\n${SYNC_MARKER}\n${importLine}\n${afterImports}`;
+        };
+        const ensureAstServerImport = (sourceCode) => ensureSyncImport(sourceCode, `import { __withEdgesServerLoad as ${AST_SERVER_LOAD_ALIAS}, __withEdgesActions as ${AST_ACTIONS_ALIAS} } from '${serverPath}';`);
+        const ensureAstUniversalImport = (sourceCode) => ensureSyncImport(sourceCode, `import { __withEdgesUniversalLoad as ${AST_UNIVERSAL_LOAD_ALIAS} } from '${packageName}';`);
+        const ensureRegexServerImport = (sourceCode) => ensureSyncImport(sourceCode, `import { __withEdgesServerLoad, __withEdgesActions } from '${serverPath}';`);
+        const ensureRegexUniversalImport = (sourceCode) => ensureSyncImport(sourceCode, `import { __withEdgesUniversalLoad } from '${packageName}';`);
+        const findExportedLocal = (sourceFile, code, exportedName) => {
+            const edits = [];
+            let localName = null;
+            let found = false;
+            for (const stmt of sourceFile.statements) {
+                if (ts.isVariableStatement(stmt)) {
+                    const exportModifier = stmt.modifiers?.find((m) => m.kind === ts.SyntaxKind.ExportKeyword);
+                    if (!exportModifier)
+                        continue;
+                    for (const declaration of stmt.declarationList.declarations) {
+                        if (!ts.isIdentifier(declaration.name))
+                            continue;
+                        if (declaration.name.text !== exportedName)
+                            continue;
+                        localName = declaration.name.text;
+                        found = true;
+                        const modifierStart = exportModifier.getStart(sourceFile);
+                        let modifierEnd = exportModifier.end;
+                        while (modifierEnd < code.length && /\s/.test(code[modifierEnd]))
+                            modifierEnd += 1;
+                        edits.push({ start: modifierStart, end: modifierEnd, text: '' });
+                        break;
+                    }
+                }
+                if (!ts.isExportDeclaration(stmt) || !stmt.exportClause || !ts.isNamedExports(stmt.exportClause) || stmt.moduleSpecifier)
+                    continue;
+                const named = stmt.exportClause;
+                const keepSpecs = [];
+                let statementHasTarget = false;
+                for (const el of named.elements) {
+                    const exportName = el.name.text;
+                    const sourceName = el.propertyName?.text ?? el.name.text;
+                    if (exportName === exportedName) {
+                        statementHasTarget = true;
+                        found = true;
+                        localName = sourceName;
+                        continue;
+                    }
+                    keepSpecs.push(code.slice(el.getStart(sourceFile), el.end).trim());
+                }
+                if (!statementHasTarget)
+                    continue;
+                if (keepSpecs.length === 0) {
+                    edits.push({ start: stmt.getStart(sourceFile), end: stmt.end, text: '' });
+                }
+                else {
+                    edits.push({ start: stmt.getStart(sourceFile), end: stmt.end, text: `export { ${keepSpecs.join(', ')} };` });
+                }
+            }
+            return { localName, edits, found };
+        };
+        const wrapServerRouteModuleRegex = (sourceCode) => {
+            if (!LOAD_EXPORT_PATTERN.test(sourceCode) && !ACTIONS_EXPORT_PATTERN.test(sourceCode)) {
+                return null;
+            }
+            let wrapped = ensureRegexServerImport(sourceCode);
+            if (LOAD_EXPORT_PATTERN.test(wrapped)) {
+                wrapped = wrapped
+                    .replace(LOAD_EXPORT_PATTERN, (match) => match.replace('export const load', 'const __userLoad'))
+                    .concat('\n\nexport const load = __withEdgesServerLoad(__userLoad);');
+            }
+            if (ACTIONS_EXPORT_PATTERN.test(wrapped)) {
+                wrapped = wrapped
+                    .replace(ACTIONS_EXPORT_PATTERN, (match) => match.replace('export const actions', 'const __userActions'))
+                    .concat('\n\nexport const actions = __withEdgesActions(__userActions);');
+            }
+            return wrapped;
+        };
+        const wrapUniversalRouteModuleRegex = (sourceCode) => {
+            if (!LOAD_EXPORT_PATTERN.test(sourceCode))
+                return null;
+            let wrapped = ensureRegexUniversalImport(sourceCode);
+            wrapped = wrapped
+                .replace(LOAD_EXPORT_PATTERN, (match) => match.replace('export const load', 'const __userUniversalLoad'))
+                .concat('\n\nexport const load = __withEdgesUniversalLoad(__userUniversalLoad);');
+            return wrapped;
+        };
+        const wrapServerRouteModuleAst = (sourceCode) => {
+            if (sourceCode.includes('__EDGES_SYNC_WRAPPED__'))
+                return null;
+            let sourceFile;
+            try {
+                sourceFile = ts.createSourceFile('route.ts', sourceCode, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+            }
+            catch {
+                return null;
+            }
+            const loadInfo = findExportedLocal(sourceFile, sourceCode, 'load');
+            const actionsInfo = findExportedLocal(sourceFile, sourceCode, 'actions');
+            if (!loadInfo.found && !actionsInfo.found)
+                return null;
+            if ((loadInfo.found && !loadInfo.localName) || (actionsInfo.found && !actionsInfo.localName))
+                return null;
+            let nextCode = applyEdits(sourceCode, [...loadInfo.edits, ...actionsInfo.edits]);
+            nextCode = ensureAstServerImport(nextCode);
+            const append = [];
+            if (loadInfo.localName) {
+                append.push(`const __edgesServerLoad = ${AST_SERVER_LOAD_ALIAS}(${loadInfo.localName});`);
+                append.push(`export { __edgesServerLoad as load };`);
+            }
+            if (actionsInfo.localName) {
+                append.push(`const __edgesServerActions = ${AST_ACTIONS_ALIAS}(${actionsInfo.localName});`);
+                append.push(`export { __edgesServerActions as actions };`);
+            }
+            return `${nextCode}\n\n${append.join('\n')}`;
+        };
+        const wrapUniversalRouteModuleAst = (sourceCode) => {
+            if (sourceCode.includes('__EDGES_SYNC_WRAPPED__'))
+                return null;
+            let sourceFile;
+            try {
+                sourceFile = ts.createSourceFile('route.ts', sourceCode, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+            }
+            catch {
+                return null;
+            }
+            const loadInfo = findExportedLocal(sourceFile, sourceCode, 'load');
+            if (!loadInfo.found || !loadInfo.localName)
+                return null;
+            let nextCode = applyEdits(sourceCode, [...loadInfo.edits]);
+            nextCode = ensureAstUniversalImport(nextCode);
+            return `${nextCode}\n\nconst __edgesUniversalLoad = ${AST_UNIVERSAL_LOAD_ALIAS}(${loadInfo.localName});\nexport { __edgesUniversalLoad as load };`;
+        };
         return {
             name: `${packageName}-auto-handle`,
             enforce: 'pre',
             transform(code, id) {
+                if (syncFromServer && SERVER_ROUTE_PATTERN.test(id) && !id.includes('hooks.server')) {
+                    const wrapped = syncTransformMode === 'regex'
+                        ? wrapServerRouteModuleRegex(code)
+                        : syncTransformMode === 'ast'
+                            ? wrapServerRouteModuleAst(code)
+                            : (wrapServerRouteModuleAst(code) ?? wrapServerRouteModuleRegex(code));
+                    if (wrapped)
+                        return { code: wrapped, map: null };
+                }
+                if (syncFromServer && UNIVERSAL_ROUTE_PATTERN.test(id) && !id.includes('.server.')) {
+                    const wrapped = syncTransformMode === 'regex'
+                        ? wrapUniversalRouteModuleRegex(code)
+                        : syncTransformMode === 'ast'
+                            ? wrapUniversalRouteModuleAst(code)
+                            : (wrapUniversalRouteModuleAst(code) ?? wrapUniversalRouteModuleRegex(code));
+                    if (wrapped)
+                        return { code: wrapped, map: null };
+                }
                 if (!id.includes('hooks.server.ts'))
                     return null;
                 if (code.includes('__EDGES_AUTO_WRAPPED__'))
@@ -34,20 +216,7 @@ export function createEdgesPluginFactory(packageName, serverPath) {
                     return null;
                 }
                 const hasHandleExport = HANDLE_EXPORT_PATTERN.test(code);
-                const compressionOptions = compression.enabled ? `, { compress: true, compressionThreshold: ${compression.threshold || 1024} }` : '';
                 const silentOption = silentChromeDevtools ? '' : `, false`;
-                const findImportInsertPosition = (sourceCode) => {
-                    const importRegex = /(?:^|\n)((?:import|export)\s+(?:type\s+)?(?:\{[^}]*\}|\*|\w+)(?:\s+from)?\s+['"][^'"]+['"];?)/gm;
-                    let lastMatch = null;
-                    let match;
-                    while ((match = importRegex.exec(sourceCode)) !== null) {
-                        lastMatch = match;
-                    }
-                    if (!lastMatch) {
-                        return 0;
-                    }
-                    return lastMatch.index + lastMatch[0].length;
-                };
                 if (!hasHandleExport) {
                     const insertPos = findImportInsertPosition(code);
                     const beforeImports = code.slice(0, insertPos);
@@ -59,7 +228,7 @@ export function createEdgesPluginFactory(packageName, serverPath) {
                             afterImports +
                             `\n\n` +
                             `export const handle = edgesHandle(({ serialize, edgesEvent, resolve }) => ` +
-                            `resolve(edgesEvent, { transformPageChunk: ({ html }) => serialize(html${compressionOptions}) })${silentOption});`,
+                            `resolve(edgesEvent, { transformPageChunk: ({ html }) => serialize(html) })${silentOption});`,
                         map: null
                     };
                 }
@@ -71,9 +240,8 @@ export function createEdgesPluginFactory(packageName, serverPath) {
                     `import { __autoWrapHandle } from '${serverPath}';\n\n` +
                     afterImports.replace(/export\s+const\s+handle\s*(?::\s*\w+\s*)?=/, 'const __userHandle =') +
                     `\n\n` +
-                    `const __compressionOptions = ${JSON.stringify({ compress: compression.enabled, compressionThreshold: compression.threshold })};\n` +
                     `const __silentChromeDevtools = ${silentChromeDevtools};\n` +
-                    `export const handle = __autoWrapHandle(__userHandle, __compressionOptions, __silentChromeDevtools);`;
+                    `export const handle = __autoWrapHandle(__userHandle, __silentChromeDevtools);`;
                 return {
                     code: wrappedCode,
                     map: null