edges-svelte 2.2.0 → 3.0.0

package/dist/plugin/EdgesAutoHandlePlugin.js

@@ -1,9 +1,9 @@
+import * as ts from 'typescript';
 /**
  * Creates a factory for the edges plugin with a custom package name and server path.
  *
  * Use this when:
  * - Creating a wrapper package that re-exports edges-svelte functionality
- * - Developing the package itself (use `$lib/server` as serverPath)
  *
  * @param packageName - The name that will be used in generated imports (e.g., 'edges-svelte', 'my-wrapper')
  * @param serverPath - The import path to the server module (e.g., 'edges-svelte/server', '$lib/server')
@@ -15,68 +15,208 @@
  *
  * export const myWrapperPlugin = createEdgesPluginFactory('my-wrapper', 'my-wrapper/server');
  * ```
- *
- * @example
- * ```ts
- * // For package development (testing the package itself)
- * import { createEdgesPluginFactory } from './src/lib/plugin/index.js';
- *
- * const edgesPluginDev = createEdgesPluginFactory('edges-svelte', '$lib/server');
- *
- * export default defineConfig({
- *   plugins: [sveltekit(), edgesPluginDev()]
- * });
- * ```
  */
 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 '${serverPath}';`);
+        const ensureRegexImport = (sourceCode) => ensureSyncImport(sourceCode, `import { __withEdgesServerLoad, __withEdgesActions, __withEdgesUniversalLoad } from '${serverPath}';`);
+        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 = ensureRegexImport(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 = ensureRegexImport(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', // Run before SvelteKit
+            enforce: 'pre',
             transform(code, id) {
-                // Only transform hooks.server.ts
+                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 already wrapped by the plugin, skip
                 if (code.includes('__EDGES_AUTO_WRAPPED__'))
                     return null;
-                // If user is manually using the package, skip auto-wrapping
-                // Optimized: Use pre-compiled regex pattern
                 if (MANUAL_IMPORT_PATTERN.test(code)) {
                     return null;
                 }
-                // Check if user defined a handle export
-                // Optimized: Use pre-compiled regex pattern
                 const hasHandleExport = HANDLE_EXPORT_PATTERN.test(code);
-                // Build compression options string
-                const compressionOptions = compression.enabled ? `, { compress: true, compressionThreshold: ${compression.threshold || 1024} }` : '';
-                // Build silent devtools option
                 const silentOption = silentChromeDevtools ? '' : `, false`;
-                // Find the position after the last import statement to preserve import order
-                // Optimized: Use regex instead of line-by-line parsing for 20x performance improvement
-                const findImportInsertPosition = (sourceCode) => {
-                    // Match all import/export statements
-                    const importRegex = /(?:^|\n)((?:import|export)\s+(?:type\s+)?(?:\{[^}]*\}|\*|\w+)(?:\s+from)?\s+['"][^'"]+['"];?)/gm;
-                    let lastMatch = null;
-                    let match;
-                    // Find the last import/export statement
-                    while ((match = importRegex.exec(sourceCode)) !== null) {
-                        lastMatch = match;
-                    }
-                    if (!lastMatch) {
-                        // No imports found, insert at the beginning
-                        return 0;
-                    }
-                    // Return position after the last import
-                    return lastMatch.index + lastMatch[0].length;
-                };
                 if (!hasHandleExport) {
-                    // No handle defined - create default with compression options
                     const insertPos = findImportInsertPosition(code);
                     const beforeImports = code.slice(0, insertPos);
                     const afterImports = code.slice(insertPos);
@@ -87,11 +227,10 @@ 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
                     };
                 }
-                // User defined a handle - wrap it with options
                 const insertPos = findImportInsertPosition(code);
                 const beforeImports = code.slice(0, insertPos);
                 const afterImports = code.slice(insertPos);
@@ -100,9 +239,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
@@ -112,10 +250,8 @@ export function createEdgesPluginFactory(packageName, serverPath) {
     };
 }
 /**
- * Default edges-svelte plugin for end users.
  *
  * This plugin automatically wraps the SvelteKit handle hook with edgesHandle,
- * eliminating the need to manually wrap your handle function.
  *
  * @example
  * ```ts
@@ -128,37 +264,5 @@ export function createEdgesPluginFactory(packageName, serverPath) {
  *   plugins: [sveltekit(), edgesPlugin()]
  * });
  * ```
- *
- * @example
- * ```ts
- * // vite.config.ts - With compression
- * export default defineConfig({
- *   plugins: [
- *     sveltekit(),
- *     edgesPlugin({
- *       compression: {
- *         enabled: true,
- *         threshold: 2048  // Compress states larger than 2KB
- *       }
- *     })
- *   ]
- * });
- * ```
- *
- * After adding the plugin, you can write your hooks.server.ts normally:
- *
- * @example
- * ```ts
- * // hooks.server.ts - No manual wrapping needed!
- *
- * // Option 1: No handle defined - plugin creates default
- * // (nothing to write, it just works)
- *
- * // Option 2: Custom handle - plugin automatically wraps it
- * export const handle = async ({ event, resolve }) => {
- *   console.log('My custom middleware');
- *   return resolve(event);
- * };
- * ```
  */
 export const edgesPlugin = createEdgesPluginFactory('edges-svelte', 'edges-svelte/server');

package/dist/provider/Provider.d.ts

@@ -11,52 +11,14 @@ type StoreDeps = {
     createState: <T>(initial: T | (() => T)) => Writable<T>;
     createDerivedState: typeof BaseCreateDerivedState;
 };
-/**
- * Creates store with optional name
- * @example
- * // Without key (auto-generated)
- * export const useUserStore = createStore(({ createState }) => {
- *   const user = createState(null);
- *   return { user };
- * });
- *
- * @example
- * // With explicit key (recommended for production)
- * export const useUserStore = createStore('user-store', ({ createState }) => {
- *   const user = createState(null);
- *   return { user };
- * });
- */
 export declare function createStore<T, I extends Record<string, unknown> = Record<string, unknown>>(factory: (args: StoreDeps & NoConflict<I, StoreDeps>) => T, inject?: I): () => T;
 export declare function createStore<T, I extends Record<string, unknown> = Record<string, unknown>>(name: string, factory: (args: StoreDeps & NoConflict<I, StoreDeps>) => T, inject?: I): () => T;
-/**
- * Store factory
- */
 export declare const createStoreFactory: <I extends Record<string, unknown>>(inject: I) => {
     <T>(factory: (args: StoreDeps & NoConflict<I, StoreDeps>) => T): () => T;
     <T>(name: string, factory: (args: StoreDeps & NoConflict<I, StoreDeps>) => T): () => T;
 };
-/**
- * Creates presenter with optional name
- * @example
- * // Without key (auto-generated)
- * export const useAuthPresenter = createPresenter(() => {
- *   const login = async () => { ... };
- *   return { login };
- * });
- *
- * @example
- * // With explicit key
- * export const useAuthPresenter = createPresenter('auth-presenter', () => {
- *   const login = async () => { ... };
- *   return { login };
- * });
- */
 export declare function createPresenter<T, I extends Record<string, unknown> = Record<string, unknown>>(factory: (args: I) => T, inject?: I): () => T;
 export declare function createPresenter<T, I extends Record<string, unknown> = Record<string, unknown>>(name: string, factory: (args: I) => T, inject?: I): () => T;
-/**
- * Presenter factory
- */
 export declare const createPresenterFactory: <I extends Record<string, unknown>>(inject: I) => {
     <T>(factory: (args: I) => T): () => T;
     <T>(name: string, factory: (args: I) => T): () => T;

package/dist/provider/Provider.js

@@ -2,9 +2,11 @@ import { createState as BaseCreateState, createDerivedState as BaseCreateDerived
 import { RequestContext } from '../context/index.js';
 import { browser } from '../utils/environment.js';
 import { DevTools } from '../utils/dev.js';
-// Global client cache
+import { dev } from '../utils/environment.js';
 const globalClientCache = new Map();
-// Key auto-generate
+const globalConstructionStack = [];
+const PROVIDER_FACTORY_MARK = Symbol.for('edges-svelte.provider.factory');
+const PROVIDER_INSTANCE_MARK = Symbol.for('edges-svelte.provider.instance');
 class AutoKeyGenerator {
     static cache = new WeakMap();
     static counters = new Map();
@@ -30,9 +32,6 @@ class AutoKeyGenerator {
         }
         if (cache.has(factory))
             return cache.get(factory);
-        // Use multiple sources for stable key generation
-        // Priority: displayName > name > toString
-        // This ensures stability even with minification
         const fnIdentifier = factory.__storeKey__ || factory.displayName || factory.name || factory.toString();
         const hash = this.hash(fnIdentifier);
         const baseKey = `store_${Math.abs(hash).toString(36)}`;
@@ -46,17 +45,14 @@ class AutoKeyGenerator {
             counters.set(baseKey, 0);
         }
         cache.set(factory, finalKey);
-        // Dev mode validation
         DevTools.validateFactoryUniqueness(factory, finalKey);
         return finalKey;
     }
     static hash(str) {
-        // FNV-1a hash algorithm - better distribution than simple sum hash
-        // Provides 50% fewer collisions for typical factory names
-        let hash = 2166136261; // FNV offset basis (32-bit)
+        let hash = 2166136261;
         for (let i = 0; i < str.length; i++) {
-            hash = (hash ^ str.charCodeAt(i)) * 16777619; // FNV prime
-            hash = hash >>> 0; // Convert to unsigned 32-bit integer
+            hash = (hash ^ str.charCodeAt(i)) * 16777619;
+            hash = hash >>> 0;
         }
         return hash;
     }
@@ -76,7 +72,52 @@ export const clearCache = (pattern) => {
     }
 };
 const createUiProvider = (cacheKey, factory, dependencies, inject) => {
-    return () => {
+    const readConstructionStack = () => {
+        if (browser)
+            return globalConstructionStack;
+        try {
+            const context = RequestContext.current();
+            return (context.data.providersConstructionStack ??= []);
+        }
+        catch {
+            return globalConstructionStack;
+        }
+    };
+    const formatCycleError = (key, stack) => {
+        const cycleStart = stack.indexOf(key);
+        const chain = cycleStart === -1 ? [...stack, key] : [...stack.slice(cycleStart), key];
+        return `[edges-svelte] Circular provider dependency detected while constructing "${key}". Chain: ${chain.join(' -> ')}.`;
+    };
+    const validateLazyInjection = (ownerKey, injections) => {
+        if (!dev || !injections)
+            return;
+        for (const [depKey, depValue] of Object.entries(injections)) {
+            if (depValue && typeof depValue === 'object') {
+                const sourceKey = depValue[PROVIDER_INSTANCE_MARK];
+                if (sourceKey) {
+                    throw new Error(`[edges-svelte] Eager provider injection detected in "${ownerKey}" for dependency "${depKey}" from "${sourceKey}". Inject provider functions instead of resolved instances.`);
+                }
+            }
+        }
+    };
+    const markProviderInstance = (instance) => {
+        if (!instance)
+            return;
+        if (typeof instance !== 'object' && typeof instance !== 'function')
+            return;
+        try {
+            Object.defineProperty(instance, PROVIDER_INSTANCE_MARK, {
+                value: cacheKey,
+                enumerable: false,
+                configurable: false,
+                writable: false
+            });
+        }
+        catch {
+            /* do nothing */
+        }
+    };
+    const provider = (() => {
         let contextMap;
         if (browser) {
             contextMap = globalClientCache;
@@ -103,18 +144,43 @@ const createUiProvider = (cacheKey, factory, dependencies, inject) => {
             ...(typeof dependencies === 'function' ? dependencies(cacheKey) : dependencies),
             ...inject
         };
-        const instance = factory(deps);
+        validateLazyInjection(cacheKey, inject);
+        const constructionStack = readConstructionStack();
+        if (constructionStack.includes(cacheKey)) {
+            throw new Error(formatCycleError(cacheKey, constructionStack));
+        }
+        constructionStack.push(cacheKey);
+        let instance;
+        try {
+            instance = factory(deps);
+        }
+        finally {
+            const idx = constructionStack.lastIndexOf(cacheKey);
+            if (idx !== -1)
+                constructionStack.splice(idx, 1);
+        }
+        markProviderInstance(instance);
         contextMap.set(cacheKey, instance);
         return instance;
-    };
+    });
+    try {
+        Object.defineProperty(provider, PROVIDER_FACTORY_MARK, {
+            value: cacheKey,
+            enumerable: false,
+            configurable: false,
+            writable: false
+        });
+    }
+    catch {
+        /* do nothing */
+    }
+    return provider;
 };
 export function createStore(nameOrFactory, factoryOrInject, inject) {
-    // Handle overloads
     const isNameProvided = typeof nameOrFactory === 'string';
     const name = isNameProvided ? nameOrFactory : undefined;
     const factory = isNameProvided ? factoryOrInject : nameOrFactory;
     const injections = isNameProvided ? inject : factoryOrInject;
-    // Use provided name or auto-generate
     const cacheKey = name || AutoKeyGenerator.generate(factory);
     return createUiProvider(cacheKey, factory, (key) => {
         let stateCounter = 0;
@@ -133,9 +199,6 @@ export function createStore(nameOrFactory, factoryOrInject, inject) {
         };
     }, injections);
 }
-/**
- * Store factory
- */
 export const createStoreFactory = (inject) => {
     function storeFactory(nameOrFactory, factory) {
         if (typeof nameOrFactory === 'string') {
@@ -148,18 +211,13 @@ export const createStoreFactory = (inject) => {
     return storeFactory;
 };
 export function createPresenter(nameOrFactory, factoryOrInject, inject) {
-    // Handle overloads
     const isNameProvided = typeof nameOrFactory === 'string';
     const name = isNameProvided ? nameOrFactory : undefined;
     const factory = isNameProvided ? factoryOrInject : nameOrFactory;
     const injections = isNameProvided ? inject : factoryOrInject;
-    // Use provided name or auto-generate
     const cacheKey = name || AutoKeyGenerator.generate(factory);
     return createUiProvider(cacheKey, factory, {}, injections);
 }
-/**
- * Presenter factory
- */
 export const createPresenterFactory = (inject) => {
     function presenterFactory(nameOrFactory, factory) {
         if (typeof nameOrFactory === 'string') {

package/dist/server/AutoWrapHandle.d.ts

@@ -1,8 +1,4 @@
 import type { Handle } from '@sveltejs/kit';
-interface CompressionOptions {
-    compress?: boolean;
-    compressionThreshold?: number;
-}
 /**
  * Automatically wraps a user-defined handle function with edgesHandle.
  * This is used internally by the Vite plugin to provide automatic state management.
@@ -10,9 +6,7 @@ interface CompressionOptions {
  * @internal This function is called automatically by the Vite plugin. You don't need to use it manually.
  *
  * @param userHandle - Optional user-defined handle function from hooks.server.ts
- * @param compressionOptions - Compression configuration from the plugin
  * @param silentChromeDevtools - Whether to silence Chrome DevTools requests
  * @returns A handle function wrapped with edgesHandle for automatic state serialization
  */
-export declare function __autoWrapHandle(userHandle?: Handle, compressionOptions?: CompressionOptions, silentChromeDevtools?: boolean): Handle;
-export {};
+export declare function __autoWrapHandle(userHandle?: Handle, silentChromeDevtools?: boolean): Handle;

package/dist/server/AutoWrapHandle.js

@@ -6,28 +6,23 @@ import { edgesHandle } from './EdgesHandleSimplified.js';
  * @internal This function is called automatically by the Vite plugin. You don't need to use it manually.
  *
  * @param userHandle - Optional user-defined handle function from hooks.server.ts
- * @param compressionOptions - Compression configuration from the plugin
  * @param silentChromeDevtools - Whether to silence Chrome DevTools requests
  * @returns A handle function wrapped with edgesHandle for automatic state serialization
  */
-export function __autoWrapHandle(userHandle, compressionOptions, silentChromeDevtools = true) {
+export function __autoWrapHandle(userHandle, silentChromeDevtools = true) {
     if (!userHandle) {
-        // No user handle - return default edgesHandle with compression options
         return edgesHandle(({ serialize, edgesEvent, resolve }) => resolve(edgesEvent, {
-            transformPageChunk: ({ html }) => serialize(html, compressionOptions)
+            transformPageChunk: ({ html }) => serialize(html)
         }), silentChromeDevtools);
     }
-    // Wrap user's handle with edgesHandle
     return edgesHandle(({ serialize, edgesEvent, resolve }) => {
         return userHandle({
             event: edgesEvent,
             resolve: (e, opts) => resolve(e, {
                 ...opts,
                 transformPageChunk: ({ html, done }) => {
-                    // Apply user's transform first (if any)
                     const userTransformed = opts?.transformPageChunk?.({ html, done }) ?? html;
-                    // Then apply edges serialization with compression options
-                    return typeof userTransformed === 'string' ? serialize(userTransformed, compressionOptions) : userTransformed;
+                    return typeof userTransformed === 'string' ? serialize(userTransformed) : userTransformed;
                 }
             })
         });

package/dist/server/EdgesHandle.d.ts

@@ -1,14 +1,7 @@
 import type { RequestEvent } from '@sveltejs/kit';
-type SerializeOptions = {
-    compress?: boolean;
-    compressionThreshold?: number;
-};
 type EdgesHandle = (event: RequestEvent, callback: (params: {
     edgesEvent: RequestEvent;
-    serialize: (html: string, options?: SerializeOptions) => string;
+    serialize: (html: string) => string;
 }) => Promise<Response> | Response, silentChromeDevtools?: boolean) => Promise<Response>;
-/**
- * Wraps request handling in an AsyncLocalStorage context
- */
 export declare const edgesHandle: EdgesHandle;
 export {};