@azure-net/kit 5.1.1 → 5.3.0

package/dist/infra/datasource/BaseDatasource.js

@@ -7,10 +7,8 @@ export class BaseHttpDatasource {
         this.httpClient = params.http ?? createHttpServiceInstance();
         this.query = params.query ?? createQueryInstance();
     }
-    async _createRawRequest(callback) {
-        return await callback({ http: this.httpClient, query: this.query }).catch((err) => {
-            throw err;
-        });
+    _createRawRequest(callback) {
+        return callback({ http: this.httpClient, query: this.query });
     }
     createRawRequest = this._createRawRequest.bind(this);
 }

package/dist/infra/query/QueryBuilder.js

@@ -8,8 +8,19 @@ const normalizeSettings = (base, override) => {
     };
 };
 const encodeQuery = (entries) => entries.map(([key, value]) => `${encodeURIComponent(key)}=${encodeURIComponent(value)}`).join('&');
+const stringifyQueryValue = (value) => {
+    try {
+        return JSON.stringify(value);
+    }
+    catch (error) {
+        const circular = error instanceof TypeError && /circular|cyclic/i.test(error.message);
+        throw new AzureNetKitInternalError(`[QueryInstance] Query value could not be serialized${circular ? ': circular reference detected' : ''}`);
+    }
+};
 const encodeArrayEntries = (key, values, arrayFormat) => {
-    const cleanValues = values.filter((v) => v !== null && v !== undefined).map((v) => String(v));
+    const cleanValues = values
+        .filter((value) => value !== null && value !== undefined)
+        .map((value) => (typeof value === 'object' && !(value instanceof Date) ? stringifyQueryValue(value) : String(value)));
     switch (arrayFormat) {
         case 'repeat':
             return cleanValues.map((v) => [key, v]);
@@ -23,26 +34,35 @@ const encodeArrayEntries = (key, values, arrayFormat) => {
             throw new AzureNetKitInternalError(`[QueryInstance] Unsupported array format: ${arrayFormat}`);
     }
 };
-const serializeEntries = (obj, arrayFormat, objectFormat, prefix = '') => {
+const serializeEntries = (obj, arrayFormat, objectFormat, prefix = '', ancestors = new WeakSet()) => {
+    if (ancestors.has(obj)) {
+        throw new AzureNetKitInternalError('[QueryInstance] Query value could not be serialized: circular reference detected');
+    }
+    ancestors.add(obj);
     const entries = [];
-    for (const [key, value] of Object.entries(obj)) {
-        if (value === null || value === undefined)
-            continue;
-        const fullKey = prefix ? (objectFormat === 'nested-brackets' ? `${prefix}[${key}]` : `${prefix}.${key}`) : key;
-        if (Array.isArray(value)) {
-            entries.push(...encodeArrayEntries(fullKey, value, arrayFormat));
-            continue;
-        }
-        if (typeof value === 'object' && !(value instanceof Date)) {
-            if (objectFormat === 'nested-brackets') {
-                entries.push(...serializeEntries(value, arrayFormat, objectFormat, fullKey));
+    try {
+        for (const [key, value] of Object.entries(obj)) {
+            if (value === null || value === undefined)
+                continue;
+            const fullKey = prefix ? (objectFormat === 'nested-brackets' ? `${prefix}[${key}]` : `${prefix}.${key}`) : key;
+            if (Array.isArray(value)) {
+                entries.push(...encodeArrayEntries(fullKey, value, arrayFormat));
+                continue;
             }
-            else {
-                entries.push([fullKey, JSON.stringify(value)]);
+            if (typeof value === 'object' && !(value instanceof Date)) {
+                if (objectFormat === 'nested-brackets') {
+                    entries.push(...serializeEntries(value, arrayFormat, objectFormat, fullKey, ancestors));
+                }
+                else {
+                    entries.push([fullKey, stringifyQueryValue(value)]);
+                }
+                continue;
             }
-            continue;
+            entries.push([fullKey, String(value)]);
         }
-        entries.push([fullKey, String(value)]);
+    }
+    finally {
+        ancestors.delete(obj);
     }
     return entries;
 };

package/dist/infra/response/BaseResponse.js

@@ -37,7 +37,7 @@ export class ResponseBuilder {
         const keys = path.split('.');
         let result = this.state.data;
         for (const key of keys) {
-            if (result && typeof result === 'object' && key in result) {
+            if (result && typeof result === 'object' && Object.hasOwn(result, key)) {
                 result = result[key];
             }
             else {

package/dist/plugin/AzureNetPlugin.js

@@ -20,10 +20,28 @@ const findStaticImportInsertPosition = (sourceCode) => {
 };
 const createVirtualServerHooks = (silentChromeDevtools) => `// ${GENERATED_MARKER}
 import { edgesHandle, edgesHandleRaw } from '${VIRTUAL_SERVER_UTILS_ID}';
+import { RequestContext } from '@azure-net/kit/server-context';
 
 const getRegister = async () => (await import('${VIRTUAL_PROGRAM_ID}')).register;
 
+const withRequestContext = (event, callback) => {
+	try {
+		RequestContext.current();
+	} catch {
+		return edgesHandleRaw(event, callback);
+	}
+
+	return callback();
+};
+
 export const init = async () => (await getRegister()).serverInit();
+export const handleFetch = (input) => withRequestContext(input.event, async () => (await getRegister()).serverFetch(input));
+export const handleValidationError = (input) => withRequestContext(
+	input.event,
+	async () => (await getRegister()).serverValidationError(input)
+);
+export const reroute = async (input) => (await getRegister()).reroute(input);
+export const getTransport = async () => (await getRegister()).transport;
 
 export const handle = edgesHandle(async ({ serialize, edgesEvent, resolve }) => {
 	const register = await getRegister();
@@ -59,8 +77,26 @@ const createVirtualServerUtils = () => "export { edgesHandle, edgesHandleRaw } f
 const createVirtualClientHooks = () => `// ${GENERATED_MARKER}
 const getRegister = async () => (await import('${VIRTUAL_PROGRAM_ID}')).register;
 
-export const init = async () => (await getRegister()).clientInit();
+export const transport = {};
+
+const createCodecView = (method) => new Proxy({}, {
+	get: (_, key) => transport[key]?.[method],
+	ownKeys: () => Reflect.ownKeys(transport),
+	getOwnPropertyDescriptor: (_, key) => key in transport
+		? { configurable: true, enumerable: true, value: transport[key][method] }
+		: undefined
+});
+
+export const decoders = createCodecView('decode');
+export const encoders = createCodecView('encode');
+
+export const init = async () => {
+	const register = await getRegister();
+	Object.assign(transport, register.transport);
+	return register.clientInit();
+};
 export const handleError = async (input) => (await getRegister()).clientError(input);
+export const reroute = async (input) => (await getRegister()).reroute(input);
 `;
 const createVirtualProgram = (root) => {
     const tsProgram = path.join(root, 'src', 'program.ts');
@@ -90,7 +126,8 @@ const hasUserHook = (root, hookName) => {
 const assertNoUserHooks = (root) => {
     const serverHook = hasUserHook(root, 'hooks.server');
     const clientHook = hasUserHook(root, 'hooks.client');
-    const hook = serverHook ?? clientHook;
+    const universalHook = hasUserHook(root, 'hooks');
+    const hook = serverHook ?? clientHook ?? universalHook;
     if (!hook)
         return;
     throw new Error(`[AzureNetPlugin] ${path.relative(root, hook)} is not allowed when AzureNetPlugin is enabled. ` +
@@ -112,21 +149,16 @@ const transformGeneratedServerInternal = (sourceCode) => {
     if (!getHooksPattern.test(sourceCode)) {
         throw new Error('[AzureNetPlugin] Unsupported SvelteKit generated server internals: get_hooks() was not found.');
     }
-    const universalImportMatch = sourceCode.match(/\(\{\s*reroute,\s*transport\s*\}\s*=\s*await\s*import\([^)]+\)\);/);
-    const universalImport = universalImportMatch?.[0] ? `\n\t${universalImportMatch[0]}` : '';
     const importLine = `import * as __azureNetServerHooks from '${VIRTUAL_SERVER_HOOKS_ID}';`;
     const getHooksReplacement = `export async function get_hooks() {
-\tlet reroute;
-\tlet transport;${universalImport}
-
 \treturn {
 \t\thandle: __azureNetServerHooks.handle,
-\t\thandleFetch: undefined,
+\t\thandleFetch: __azureNetServerHooks.handleFetch,
 \t\thandleError: __azureNetServerHooks.handleError,
-\t\thandleValidationError: undefined,
+\t\thandleValidationError: __azureNetServerHooks.handleValidationError,
 \t\tinit: __azureNetServerHooks.init,
-\t\treroute,
-\t\ttransport
+\t\treroute: __azureNetServerHooks.reroute,
+\t\ttransport: await __azureNetServerHooks.getTransport()
 \t};
 }`;
     const transformed = ensureVirtualImport(sourceCode, `// ${GENERATED_MARKER}\n${importLine}`).replace(getHooksPattern, getHooksReplacement);
@@ -142,6 +174,11 @@ const transformGeneratedClientApp = (sourceCode) => {
     if (!handleErrorPattern.test(sourceCode)) {
         throw new Error('[AzureNetPlugin] Unsupported SvelteKit generated client app: default handleError was not found.');
     }
+    const decodersPattern = /export const decoders = Object\.fromEntries\(Object\.entries\(hooks\.transport\)\.map\(\(\[k, v\]\) => \[k, v\.decode\]\)\);/;
+    const encodersPattern = /export const encoders = Object\.fromEntries\(Object\.entries\(hooks\.transport\)\.map\(\(\[k, v\]\) => \[k, v\.encode\]\)\);/;
+    if (!decodersPattern.test(sourceCode) || !encodersPattern.test(sourceCode)) {
+        throw new Error('[AzureNetPlugin] Unsupported SvelteKit generated client app: transport codecs were not found.');
+    }
     let transformed = ensureVirtualImport(sourceCode, `// ${GENERATED_MARKER}\nimport * as __azureNetClientHooks from '${VIRTUAL_CLIENT_HOOKS_ID}';`);
     transformed = transformed.replace(handleErrorPattern, 'handleError: __azureNetClientHooks.handleError');
     if (/^\s*init:\s*[^,\n]+,?/m.test(transformed)) {
@@ -150,6 +187,10 @@ const transformGeneratedClientApp = (sourceCode) => {
     else {
         transformed = transformed.replace(/handleError:\s*__azureNetClientHooks\.handleError,?/m, 'handleError: __azureNetClientHooks.handleError,\n\tinit: __azureNetClientHooks.init,');
     }
+    transformed = transformed.replace(/^\s*reroute:\s*[^,\n]+,?/m, '\treroute: __azureNetClientHooks.reroute,');
+    transformed = transformed.replace(/^\s*transport:\s*[^,\n]+,?/m, '\ttransport: __azureNetClientHooks.transport');
+    transformed = transformed.replace(decodersPattern, 'export const decoders = __azureNetClientHooks.decoders;');
+    transformed = transformed.replace(encodersPattern, 'export const encoders = __azureNetClientHooks.encoders;');
     return transformed;
 };
 export const AzureNetPlugin = (options) => {

package/dist/shared/app/App.d.ts

@@ -1,6 +1,6 @@
 import { type ContextData } from '../../external/edges/ServerContext.js';
 import { type IServerMiddleware } from './middleware/ServerMiddleware.js';
-import type { Handle, HandleClientError, HandleServerError, RequestEvent, ServerInit } from '@sveltejs/kit';
+import type { Handle, HandleClientError, HandleFetch, HandleServerError, HandleValidationError, RequestEvent, Reroute, ServerInit, Transport } from '@sveltejs/kit';
 import { type IClientMiddleware } from './middleware/ClientMiddleware.js';
 import { useLogger } from '../logger/index.js';
 type MaybePromise<T> = T | Promise<T>;
@@ -11,7 +11,7 @@ type AppDependencyFactories<TApp> = Record<string, AppDependencyFactory<TApp>>;
 type ResolvedDependencies<T> = {
     [K in keyof T]: T[K] extends (...args: never[]) => infer TReturn ? TReturn : never;
 };
-type BuilderFlags = Partial<Record<'use' | 'useClient' | 'useClientInit' | 'useClientError' | 'useServerInit' | 'useServer' | 'useServerError', true>>;
+type BuilderFlags = Partial<Record<'use' | 'useClient' | 'useClientInit' | 'useClientError' | 'useServerInit' | 'useServer' | 'useServerError' | 'useServerFetch' | 'useServerValidationError' | 'useReroute' | 'useTransport', true>>;
 type WithFlag<TFlags extends BuilderFlags, TKey extends keyof BuilderFlags> = TFlags & Record<TKey, true>;
 type BuilderDependencies<TBuilder> = TBuilder extends {
     readonly __types__?: infer TDependencies;
@@ -55,6 +55,14 @@ export interface AppServerErrorContext<TDependencies extends Record<string, unkn
     message: string;
     useLogger: typeof useLogger;
 }
+export type AppServerFetchContext<TDependencies extends Record<string, unknown>> = Parameters<HandleFetch>[0] & {
+    Container: AppContainer<TDependencies>;
+    requestContext: ContextData;
+};
+export type AppServerValidationErrorContext<TDependencies extends Record<string, unknown>> = Parameters<HandleValidationError>[0] & {
+    Container: AppContainer<TDependencies>;
+    requestContext: ContextData;
+};
 export type AppUniversalLifecycleCallback<TDependencies extends Record<string, unknown>> = (context: AppUniversalLifecycleContext<TDependencies>) => MaybePromise<void>;
 export type AppClientLifecycleCallback<TDependencies extends Record<string, unknown>> = (context: AppClientLifecycleContext<TDependencies>) => MaybePromise<void>;
 export type AppClientInitLifecycleCallback<TDependencies extends Record<string, unknown>> = (context: AppClientInitLifecycleContext<TDependencies>) => MaybePromise<void>;
@@ -62,6 +70,9 @@ export type AppClientErrorCallback<TDependencies extends Record<string, unknown>
 export type AppServerInitLifecycleCallback = ServerInit;
 export type AppServerLifecycleCallback<TDependencies extends Record<string, unknown>> = (context: AppServerLifecycleContext<TDependencies>) => MaybePromise<Response | void>;
 export type AppServerErrorCallback<TDependencies extends Record<string, unknown>> = (context: AppServerErrorContext<TDependencies>) => ReturnType<HandleServerError>;
+export type AppServerFetchCallback<TDependencies extends Record<string, unknown>> = (context: AppServerFetchContext<TDependencies>) => ReturnType<HandleFetch>;
+export type AppServerValidationErrorCallback<TDependencies extends Record<string, unknown>> = (context: AppServerValidationErrorContext<TDependencies>) => ReturnType<HandleValidationError>;
+export type AppRerouteCallback = Reroute;
 export type CreateAppBuilder<TDependencies extends Record<string, unknown>, TFlags extends BuilderFlags = object> = {
     readonly __types__?: TDependencies;
     dependencies<TNext extends AppDependencyFactories<AppContainer<TDependencies>>>(dependencies: TNext): CreateAppBuilder<TDependencies & ResolvedDependencies<TNext>, TFlags>;
@@ -79,6 +90,14 @@ export type CreateAppBuilder<TDependencies extends Record<string, unknown>, TFla
     useServer(callback: AppServerLifecycleCallback<TDependencies>): CreateAppBuilder<TDependencies, WithFlag<TFlags, 'useServer'>>;
 }> & OnceMethod<TFlags, 'useServerError', {
     useServerError(callback: AppServerErrorCallback<TDependencies>): CreateAppBuilder<TDependencies, WithFlag<TFlags, 'useServerError'>>;
+}> & OnceMethod<TFlags, 'useServerFetch', {
+    useServerFetch(callback: AppServerFetchCallback<TDependencies>): CreateAppBuilder<TDependencies, WithFlag<TFlags, 'useServerFetch'>>;
+}> & OnceMethod<TFlags, 'useServerValidationError', {
+    useServerValidationError(callback: AppServerValidationErrorCallback<TDependencies>): CreateAppBuilder<TDependencies, WithFlag<TFlags, 'useServerValidationError'>>;
+}> & OnceMethod<TFlags, 'useReroute', {
+    useReroute(callback: AppRerouteCallback): CreateAppBuilder<TDependencies, WithFlag<TFlags, 'useReroute'>>;
+}> & OnceMethod<TFlags, 'useTransport', {
+    useTransport(transport: Transport): CreateAppBuilder<TDependencies, WithFlag<TFlags, 'useTransport'>>;
 }>;
 export interface AppRegistrar {
     (): MaybePromise<void>;
@@ -86,7 +105,11 @@ export interface AppRegistrar {
     clientError: HandleClientError;
     serverInit: ServerInit;
     serverError: HandleServerError;
+    serverFetch: HandleFetch;
+    serverValidationError: HandleValidationError;
     handle: Handle;
+    reroute: Reroute;
+    transport: Transport;
 }
 export interface CreateAppInstance<TDependencies extends Record<string, unknown>> {
     Container: AppContainer<TDependencies>;

package/dist/shared/app/App.js

@@ -79,6 +79,22 @@ const createBuilder = (dependencies, callbacks) => {
             setCallback(callbacks, 'useServerError', callback);
             return builder;
         },
+        useServerFetch(callback) {
+            setCallback(callbacks, 'useServerFetch', callback);
+            return builder;
+        },
+        useServerValidationError(callback) {
+            setCallback(callbacks, 'useServerValidationError', callback);
+            return builder;
+        },
+        useReroute(callback) {
+            setCallback(callbacks, 'useReroute', callback);
+            return builder;
+        },
+        useTransport(transport) {
+            setCallback(callbacks, 'useTransport', transport);
+            return builder;
+        },
         dependencies(nextDependencies) {
             for (const [key, factory] of Object.entries(nextDependencies)) {
                 dependencies.set(key, factory);
@@ -195,6 +211,27 @@ export const createApp = (callback, name = DEFAULT_APP_NAME) => {
             message
         });
     };
+    const runServerFetch = (input) => {
+        if (!callbacks.useServerFetch)
+            return input.fetch(input.request);
+        return callbacks.useServerFetch({
+            ...input,
+            Container,
+            requestContext: getServerRequestContext()
+        });
+    };
+    const runServerValidationError = (input) => {
+        if (!callbacks.useServerValidationError) {
+            console.error('Remote function schema validation failed:', input.issues);
+            return { message: 'Bad Request' };
+        }
+        return callbacks.useServerValidationError({
+            ...input,
+            Container,
+            requestContext: getServerRequestContext()
+        });
+    };
+    const reroute = (input) => callbacks.useReroute?.(input);
     const handle = async ({ event, resolve }) => {
         const requestContext = getServerRequestContext();
         const flags = getLifecycleFlags(appKey, requestContext);
@@ -227,7 +264,11 @@ export const createApp = (callback, name = DEFAULT_APP_NAME) => {
         clientError: runClientError,
         serverInit: runServerInit,
         serverError: runServerError,
-        handle
+        serverFetch: runServerFetch,
+        serverValidationError: runServerValidationError,
+        handle,
+        reroute,
+        transport: callbacks.useTransport ?? {}
     });
     return {
         Container,

package/dist/shared/app/index.d.ts

@@ -1,4 +1,4 @@
-export { createApp, type AppClientErrorCallback, type AppClientErrorContext, type AppClientInitLifecycleCallback, type AppClientInitLifecycleContext, type AppClientLifecycleCallback, type AppClientLifecycleContext, type AppContainer, type AppRegistrar, type AppServerErrorCallback, type AppServerErrorContext, type AppServerInitLifecycleCallback, type AppServerInitLifecycleContext, type AppServerLifecycleCallback, type AppServerLifecycleContext, type AppUniversalLifecycleCallback, type AppUniversalLifecycleContext, type CreateAppInstance } from './App.js';
+export { createApp, type AppClientErrorCallback, type AppClientErrorContext, type AppClientInitLifecycleCallback, type AppClientInitLifecycleContext, type AppClientLifecycleCallback, type AppClientLifecycleContext, type AppContainer, type AppRegistrar, type AppServerErrorCallback, type AppServerErrorContext, type AppServerFetchCallback, type AppServerFetchContext, type AppServerInitLifecycleCallback, type AppServerInitLifecycleContext, type AppServerLifecycleCallback, type AppServerLifecycleContext, type AppServerValidationErrorCallback, type AppServerValidationErrorContext, type AppRerouteCallback, type AppUniversalLifecycleCallback, type AppUniversalLifecycleContext, type CreateAppInstance } from './App.js';
 export type { IClientMiddleware } from './middleware/ClientMiddleware.js';
 export type { IServerMiddleware } from './middleware/ServerMiddleware.js';
 export type { EnsureRoute, EnsureRouteSource, EnsureRouteTarget } from './middleware/Shared.js';

package/dist/shared/background-task/BackgroundTask.d.ts

@@ -0,0 +1,16 @@
+type MaybePromise<T> = T | PromiseLike<T>;
+type WaitUntil = (promise: Promise<unknown>) => void;
+type WaitUntilTarget = WaitUntil | {
+    waitUntil: WaitUntil;
+};
+export declare class BackgroundTask<T = void> implements Promise<T> {
+    #private;
+    readonly [Symbol.toStringTag] = "Promise";
+    private constructor();
+    static run<T = void>(task: () => MaybePromise<T>): BackgroundTask<T>;
+    waitUntil(target: WaitUntilTarget): this;
+    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | null, onrejected?: ((reason: unknown) => TResult2 | PromiseLike<TResult2>) | null): Promise<TResult1 | TResult2>;
+    catch<TResult = never>(onrejected?: ((reason: unknown) => TResult | PromiseLike<TResult>) | null): Promise<T | TResult>;
+    finally(onfinally?: (() => void) | null): Promise<T>;
+}
+export {};

package/dist/shared/background-task/BackgroundTask.js

@@ -0,0 +1,34 @@
+export class BackgroundTask {
+    [Symbol.toStringTag] = 'Promise';
+    #promise;
+    constructor(task) {
+        try {
+            this.#promise = Promise.resolve(task());
+        }
+        catch (error) {
+            this.#promise = Promise.reject(error);
+        }
+        void this.#promise.catch(() => undefined);
+    }
+    static run(task) {
+        return new BackgroundTask(task);
+    }
+    waitUntil(target) {
+        if (typeof target === 'function') {
+            target(this.#promise);
+        }
+        else {
+            target.waitUntil(this.#promise);
+        }
+        return this;
+    }
+    then(onfulfilled, onrejected) {
+        return this.#promise.then(onfulfilled, onrejected);
+    }
+    catch(onrejected) {
+        return this.#promise.catch(onrejected);
+    }
+    finally(onfinally) {
+        return this.#promise.finally(onfinally);
+    }
+}

package/dist/shared/background-task/index.d.ts

@@ -0,0 +1 @@
+export { BackgroundTask } from './BackgroundTask.js';

package/dist/shared/background-task/index.js

@@ -0,0 +1 @@
+export { BackgroundTask } from './BackgroundTask.js';

package/dist/shared/boundary-provider/Provider.d.ts

@@ -17,5 +17,5 @@ export interface ProviderSettings<T extends ServiceMap, D extends Record<string,
     register: ProviderFactory<T, D>;
 }
 export declare const createBoundaryProvider: <T extends ServiceMap, D extends Record<string, ProviderWithType<ServiceMap>>>(name: string, settings: ProviderSettings<T, D>) => ProviderWithType<T>;
-export declare function cleanupProvider(name: string): void;
+export declare function cleanupProvider(name: string): Promise<void>;
 export {};

package/dist/shared/boundary-provider/Provider.js

@@ -152,14 +152,17 @@ export const createBoundaryProvider = (name, settings) => {
     };
     return providerFn;
 };
-export function cleanupProvider(name) {
+export async function cleanupProvider(name) {
     const cleanupCache = async (cache) => {
         const promises = [];
         for (const [key, service] of cache.entries()) {
             if (service && typeof service === 'object' && 'dispose' in service) {
-                const disposeResult = service.dispose();
-                if (disposeResult instanceof Promise) {
-                    promises.push(disposeResult.catch((err) => console.error(`Error disposing ${name}.${key}:`, err)));
+                try {
+                    const disposeResult = service.dispose();
+                    promises.push(Promise.resolve(disposeResult).catch((err) => console.error(`Error disposing ${name}.${key}:`, err)));
+                }
+                catch (err) {
+                    console.error(`Error disposing ${name}.${key}:`, err);
                 }
             }
         }
@@ -168,18 +171,19 @@ export function cleanupProvider(name) {
     };
     if (BROWSER) {
         const cache = clientCache.get(name);
-        if (cache) {
-            void cleanupCache(cache);
-        }
+        clientCache.delete(name);
         providerProxyCache.delete(name);
         clientBootFlags.delete(name);
+        if (cache)
+            await cleanupCache(cache);
     }
     else {
         const context = RequestContext.current();
         const providers = context.data.providers;
         if (providers?.has(name)) {
             const cache = providers.get(name);
-            void cleanupCache(cache);
+            providers.delete(name);
+            await cleanupCache(cache);
         }
     }
 }

package/dist/shared/class-mirror/ClassMirror.js

@@ -26,12 +26,6 @@ export class ClassMirror {
             },
             has(proxyTarget, prop) {
                 return Reflect.has(proxyTarget, prop) || Reflect.has(proxyTarget[MIRROR_TARGET], prop);
-            },
-            ownKeys(proxyTarget) {
-                return [...new Set([...Reflect.ownKeys(proxyTarget), ...Reflect.ownKeys(proxyTarget[MIRROR_TARGET])])];
-            },
-            getOwnPropertyDescriptor(proxyTarget, prop) {
-                return Reflect.getOwnPropertyDescriptor(proxyTarget, prop) ?? Reflect.getOwnPropertyDescriptor(proxyTarget[MIRROR_TARGET], prop);
             }
         });
     }

package/dist/shared/cookie/UniversalCookie.d.ts

@@ -9,12 +9,42 @@ export type CookieOptions = {
     priority?: 'low' | 'medium' | 'high' | undefined;
     partitioned?: boolean | undefined;
 };
+/** Cookie operations with shared defaults and request-local resolution at call time. */
+export declare class UniversalCookieInstance {
+    private readonly defaults;
+    constructor(options?: CookieOptions);
+    set<T>(name: string, value: T, options?: CookieOptions): void;
+    get<T = string>(name: string): T | undefined;
+    getAll<T = Record<string, unknown>>(): T | undefined;
+    has(name: string): boolean;
+    delete(name: string, options?: CookieOptions): void;
+    clear(options?: CookieOptions): void;
+    toCredentials(): string;
+    createNamedInstance<T = string>(name: string): UniversalNamedCookieInstance<T>;
+}
+/** Type-safe operations for one cookie name. */
+export declare class UniversalNamedCookieInstance<T = string> {
+    readonly name: string;
+    private readonly cookies;
+    constructor(name: string, cookies: UniversalCookieInstance);
+    set(value: T, options?: CookieOptions): void;
+    get(): T | undefined;
+    has(): boolean;
+    delete(options?: CookieOptions): void;
+    clear(options?: CookieOptions): void;
+}
 /**
  * Utility class for managing cookies in svelte ssr (browser and server).
  * Supports setting, getting, deleting, checking, and clearing cookies.
  * All methods are static and operate without creating instances.
  */
 export declare class UniversalCookie {
+    /** Creates reusable cookie operations with shared defaults. */
+    static createInstance(options?: CookieOptions): UniversalCookieInstance;
+    /** Creates reusable operations bound to one cookie name. */
+    static createNamedInstance<T = string>(name: string, options?: CookieOptions): UniversalNamedCookieInstance<T>;
+    private static serialize;
+    private static deserialize;
     /**
      * Sets a cookie with the specified key, value, and options.
      * Serializes non-string values as JSON.

package/dist/shared/cookie/UniversalCookie.js

@@ -1,11 +1,111 @@
 import { BROWSER, Cookies } from '../../external/tools/index.js';
 import { RequestContext } from '../../external/edges/ServerContext.js';
+const cloneCookieOptions = (options) => ({
+    ...options,
+    expires: options.expires instanceof Date ? new Date(options.expires) : options.expires
+});
+const mergeCookieOptions = (defaults, overrides) => overrides ? { ...defaults, ...overrides } : defaults;
+/** Cookie operations with shared defaults and request-local resolution at call time. */
+export class UniversalCookieInstance {
+    defaults;
+    constructor(options = {}) {
+        this.defaults = cloneCookieOptions(options);
+    }
+    set(name, value, options) {
+        UniversalCookie.set(name, value, mergeCookieOptions(this.defaults, options));
+    }
+    get(name) {
+        return UniversalCookie.get(name);
+    }
+    getAll() {
+        return UniversalCookie.getAll();
+    }
+    has(name) {
+        return UniversalCookie.has(name);
+    }
+    delete(name, options) {
+        UniversalCookie.delete(name, mergeCookieOptions(this.defaults, options));
+    }
+    clear(options) {
+        UniversalCookie.clear(mergeCookieOptions(this.defaults, options));
+    }
+    toCredentials() {
+        return UniversalCookie.toCredentials();
+    }
+    createNamedInstance(name) {
+        return new UniversalNamedCookieInstance(name, this);
+    }
+}
+/** Type-safe operations for one cookie name. */
+export class UniversalNamedCookieInstance {
+    name;
+    cookies;
+    constructor(name, cookies) {
+        if (!name)
+            throw new TypeError('Cookie name must not be empty.');
+        this.name = name;
+        this.cookies = cookies;
+    }
+    set(value, options) {
+        this.cookies.set(this.name, value, options);
+    }
+    get() {
+        return this.cookies.get(this.name);
+    }
+    has() {
+        return this.cookies.has(this.name);
+    }
+    delete(options) {
+        this.cookies.delete(this.name, options);
+    }
+    clear(options) {
+        this.delete(options);
+    }
+}
 /**
  * Utility class for managing cookies in svelte ssr (browser and server).
  * Supports setting, getting, deleting, checking, and clearing cookies.
  * All methods are static and operate without creating instances.
  */
 export class UniversalCookie {
+    /** Creates reusable cookie operations with shared defaults. */
+    static createInstance(options = {}) {
+        return new UniversalCookieInstance(options);
+    }
+    /** Creates reusable operations bound to one cookie name. */
+    static createNamedInstance(name, options = {}) {
+        return this.createInstance(options).createNamedInstance(name);
+    }
+    static serialize(value) {
+        if (typeof value === 'string')
+            return value;
+        const serialized = JSON.stringify(value);
+        if (serialized === undefined)
+            throw new TypeError('Cookie value is not JSON-serializable.');
+        return serialized;
+    }
+    static deserialize(value, decodeLegacy = false) {
+        try {
+            return JSON.parse(value);
+        }
+        catch {
+            if (!decodeLegacy)
+                return value;
+        }
+        let decodedValue;
+        try {
+            decodedValue = decodeURIComponent(value);
+        }
+        catch {
+            return value;
+        }
+        try {
+            return JSON.parse(decodedValue);
+        }
+        catch {
+            return decodedValue;
+        }
+    }
     /**
      * Sets a cookie with the specified key, value, and options.
      * Serializes non-string values as JSON.
@@ -17,21 +117,14 @@ export class UniversalCookie {
      * @returns {void}
      */
     static set(name, value, options) {
+        const serializedValue = this.serialize(value);
         if (BROWSER) {
-            Cookies.set(name, value, options);
+            Cookies.set(name, serializedValue, options);
             return;
         }
         else {
             const event = RequestContext.current().event;
             if (event) {
-                const encodedKey = encodeURIComponent(name);
-                let serializedValue;
-                if (typeof value === 'string') {
-                    serializedValue = encodeURIComponent(value);
-                }
-                else {
-                    serializedValue = encodeURIComponent(JSON.stringify(value));
-                }
                 let expires;
                 if (options?.expires !== undefined) {
                     if (typeof options.expires === 'number') {
@@ -43,7 +136,7 @@ export class UniversalCookie {
                         expires = options.expires;
                     }
                 }
-                event.cookies.set(encodedKey, serializedValue, {
+                event.cookies.set(name, serializedValue, {
                     ...options,
                     path: options?.path ?? '/',
                     httpOnly: options?.httpOnly ?? false,
@@ -64,22 +157,15 @@ export class UniversalCookie {
      */
     static get(name) {
         if (BROWSER) {
-            return Cookies.get(name) ?? undefined;
+            const value = Cookies.get(name, { parse: false });
+            return value === null ? undefined : this.deserialize(value);
         }
         else {
             const event = RequestContext.current().event;
             if (event) {
-                const encodedKey = encodeURIComponent(name);
-                const cookieValue = event.cookies.get(encodedKey);
-                if (cookieValue) {
-                    const decodedValue = decodeURIComponent(cookieValue);
-                    try {
-                        return JSON.parse(decodedValue);
-                    }
-                    catch {
-                        return decodedValue;
-                    }
-                }
+                const cookieValue = event.cookies.get(name) ?? event.cookies.get(encodeURIComponent(name));
+                if (cookieValue !== undefined)
+                    return this.deserialize(cookieValue, true);
                 return undefined;
             }
             return undefined;
@@ -94,7 +180,8 @@ export class UniversalCookie {
      */
     static getAll() {
         if (BROWSER) {
-            return Cookies.getAll();
+            const allCookies = Cookies.getAll({ parse: false });
+            return Object.fromEntries(Object.entries(allCookies).map(([name, value]) => [name, this.deserialize(String(value))]));
         }
         else {
             const event = RequestContext.current().event;
@@ -102,12 +189,7 @@ export class UniversalCookie {
             if (event) {
                 const allCookies = event.cookies.getAll();
                 for (const singleCookie of allCookies) {
-                    try {
-                        result[singleCookie.name] = JSON.parse(singleCookie.value);
-                    }
-                    catch {
-                        result[singleCookie.name] = singleCookie.value;
-                    }
+                    result[singleCookie.name] = this.deserialize(singleCookie.value, true);
                 }
             }
             return result;
@@ -154,7 +236,10 @@ export class UniversalCookie {
     static toCredentials() {
         const all = this.getAll() ?? {};
         return Object.entries(all)
-            .map(([k, v]) => `${encodeURIComponent(k)}=${encodeURIComponent(v)}`)
+            .map(([key, value]) => {
+            const serialized = typeof value === 'string' ? value : JSON.stringify(value);
+            return `${encodeURIComponent(key)}=${encodeURIComponent(serialized)}`;
+        })
             .join('; ');
     }
 }

package/dist/shared/event-bus/EventBus.d.ts

@@ -1,2 +1,12 @@
 import { EventBus } from '../../external/tools/index.js';
-export declare const AppEvents: () => EventBus<any>;
+declare global {
+    namespace App {
+        interface CustomEvents {
+            readonly __azureNetEvents__?: never;
+        }
+    }
+}
+export type AppEventsList = App.CustomEvents extends {
+    list: infer TEvents extends object;
+} ? TEvents : Record<never, never>;
+export declare const AppEvents: () => EventBus<AppEventsList>;

package/dist/shared/event-bus/EventBus.js

@@ -1,6 +1,3 @@
 import { EventBus } from '../../external/tools/index.js';
 import { createPresenter } from '../../external/edges/Edges.js';
-export const AppEvents = createPresenter(() => {
-    const appEventBus = new EventBus({});
-    return appEventBus;
-});
+export const AppEvents = createPresenter(() => new EventBus({}));

package/dist/shared/index.d.ts

@@ -1,7 +1,8 @@
-export { UniversalCookie, type CookieOptions } from './cookie/index.js';
+export { UniversalCookie, UniversalCookieInstance, UniversalNamedCookieInstance, type CookieOptions } from './cookie/index.js';
+export { BackgroundTask } from './background-task/index.js';
 export { AppEvents } from './event-bus/index.js';
 export { ClassMirror } from './class-mirror/index.js';
 export { createBoundaryProvider, cleanupProvider, type ProviderSettings } from './boundary-provider/index.js';
-export { createApp, type AppContainer, type CreateAppInstance, type IServerMiddleware, type IClientMiddleware } from './app/index.js';
+export * from './app/index.js';
 export { useLogger, LoggerErrors, type ILoggerError, type ILoggerSettings } from './logger/index.js';
 export { useRedirect, type IRedirectSettings, type RedirectStatus } from './redirect/index.js';

package/dist/shared/index.js

@@ -1,7 +1,8 @@
-export { UniversalCookie } from './cookie/index.js';
+export { UniversalCookie, UniversalCookieInstance, UniversalNamedCookieInstance } from './cookie/index.js';
+export { BackgroundTask } from './background-task/index.js';
 export { AppEvents } from './event-bus/index.js';
 export { ClassMirror } from './class-mirror/index.js';
 export { createBoundaryProvider, cleanupProvider } from './boundary-provider/index.js';
-export { createApp } from './app/index.js';
+export * from './app/index.js';
 export { useLogger, LoggerErrors } from './logger/index.js';
 export { useRedirect } from './redirect/index.js';

package/dist/shared/logger/index.d.ts

@@ -1,4 +1,5 @@
 import { AppError, type IAppError } from '../app-error/index.js';
+import { BackgroundTask } from '../background-task/index.js';
 export declare enum LoggerErrors {
     AzureNetKitInternal = 0,
     AzureNetAppError = 1,
@@ -20,4 +21,4 @@ export interface ILoggerSettings {
     filterLog?: (error: ILoggerError) => boolean;
     includeOnly?: LoggerErrors[];
 }
-export declare const useLogger: (error: unknown, settings: ILoggerSettings) => void;
+export declare const useLogger: (error: unknown, settings: ILoggerSettings) => BackgroundTask<void>;

package/dist/shared/logger/index.js

@@ -1,6 +1,7 @@
 import { AppError, AzureNetKitInternalError } from '../app-error/index.js';
 import { BROWSER } from '../../external/tools/index.js';
 import { RequestContext } from '../../external/edges/ServerContext.js';
+import { BackgroundTask } from '../background-task/index.js';
 export var LoggerErrors;
 (function (LoggerErrors) {
     LoggerErrors[LoggerErrors["AzureNetKitInternal"] = 0] = "AzureNetKitInternal";
@@ -50,24 +51,28 @@ const getFetcher = () => {
 export const useLogger = (error, settings) => {
     const preparedError = prepareError(error);
     if (settings.filterLog && settings.filterLog(preparedError)) {
-        return;
+        return BackgroundTask.run(() => undefined);
     }
     if (settings.includeOnly && !settings.includeOnly.includes(preparedError.type)) {
-        return;
+        return BackgroundTask.run(() => undefined);
     }
     const prefix = settings?.prefix ?? '[Logger]';
     const errorMessage = prefix + preparedError.message + (settings?.joinToLog ? settings.joinToLog(preparedError) : '');
     console.log(errorMessage);
-    if (settings.collector) {
-        const fetcher = getFetcher();
+    if (!settings.collector)
+        return BackgroundTask.run(() => undefined);
+    const { collector } = settings;
+    return BackgroundTask.run(async () => {
         try {
-            void fetcher(settings.collector.request(preparedError)).catch((err) => {
-                settings.collector?.onError?.(err);
-                return;
-            });
+            await getFetcher()(collector.request(preparedError));
         }
         catch (err) {
-            settings.collector.onError?.(err);
+            try {
+                collector.onError?.(err);
+            }
+            catch {
+                return;
+            }
         }
-    }
+    });
 };

package/dist/svelte/active-form/ActiveForm.svelte.js

@@ -1,10 +1,11 @@
 import { ObjectUtil } from '../../external/tools/index.js';
+import { cloneStateValue } from '../shared/cloneStateValue.js';
 export const createActiveForm = (onSubmit, config) => {
     const isPromise = (value) => {
         return typeof value?.then === 'function';
     };
     let initial = {};
-    let formData = $state(ObjectUtil.deepClone(initial));
+    let formData = $state(cloneStateValue(initial));
     let formErrors = $state({});
     let pending = $state(false);
     let submitRunId = 0;
@@ -15,18 +16,18 @@ export const createActiveForm = (onSubmit, config) => {
         const source = config?.initialData;
         if (!source) {
             initial = {};
-            formData = ObjectUtil.deepClone(initial);
+            formData = cloneStateValue(initial);
             formErrors = {};
-            return initial;
+            return cloneStateValue(initial);
         }
         const value = source();
         const nextInitial = isPromise(value) ? await value : value;
         if (runId !== initialLoadRunId)
-            return initial;
-        initial = (nextInitial ?? {});
-        formData = ObjectUtil.deepClone(initial);
+            return cloneStateValue(initial);
+        initial = cloneStateValue((nextInitial ?? {}));
+        formData = cloneStateValue(initial);
         formErrors = {};
-        return initial;
+        return cloneStateValue(initial);
     };
     const ready = loadInitialData();
     const abortedResponse = () => ({
@@ -45,7 +46,7 @@ export const createActiveForm = (onSubmit, config) => {
                 formData = {};
                 break;
             case 'initial':
-                formData = ObjectUtil.deepClone(initial);
+                formData = cloneStateValue(initial);
                 break;
             case 'reloadInitial':
                 await loadInitialData();
@@ -70,7 +71,7 @@ export const createActiveForm = (onSubmit, config) => {
                 if (aborted || runId !== submitRunId)
                     return abortedResponse();
             }
-            const result = await onSubmit($state.snapshot(formData));
+            const result = await onSubmit(cloneStateValue(formData));
             if (runId !== submitRunId)
                 return result;
             if (result.success) {

package/dist/svelte/async-signal/AsyncSignal.svelte.js

@@ -124,6 +124,9 @@ export const createAsyncSignal = (handler, options = {}) => {
         }
         await start('manual');
     };
+    const refresh = async () => {
+        await start('manual');
+    };
     if (BROWSER) {
         const signalKey = key ?? asyncSignalManager.generateKey();
         const callback = (source) => start(source);
@@ -163,7 +166,7 @@ export const createAsyncSignal = (handler, options = {}) => {
             return start('auto');
         },
         execute,
-        refresh: execute,
+        refresh,
         reset: () => {
             currentRunId += 1;
             abortController?.abort();

package/dist/svelte/query/Query.svelte.js

@@ -1,24 +1,55 @@
-import { ObjectUtil } from '../../external/tools/index.js';
 import { untrack } from 'svelte';
+import { ObjectUtil } from '../../external/tools/index.js';
+import { cloneStateValue } from '../shared/cloneStateValue.js';
+const trackDeep = (value, seen = new WeakSet()) => {
+    if (value === null || typeof value !== 'object' || seen.has(value))
+        return;
+    seen.add(value);
+    if (Array.isArray(value)) {
+        for (const item of value)
+            trackDeep(item, seen);
+        return;
+    }
+    if (value instanceof Map) {
+        for (const [key, item] of value) {
+            trackDeep(key, seen);
+            trackDeep(item, seen);
+        }
+        return;
+    }
+    if (value instanceof Set) {
+        for (const item of value)
+            trackDeep(item, seen);
+        return;
+    }
+    const prototype = Object.getPrototypeOf(value);
+    if (prototype !== Object.prototype && prototype !== null)
+        return;
+    for (const key of Reflect.ownKeys(value)) {
+        trackDeep(Reflect.get(value, key), seen);
+    }
+};
 export const createQuery = (initialValue, options) => {
-    const baseInitial = ObjectUtil.deepClone(initialValue);
-    let data = $state(ObjectUtil.deepClone(baseInitial));
-    const includeKeys = options?.onChange?.include ?? [];
+    const baseInitial = cloneStateValue(initialValue);
+    let data = $state(cloneStateValue(baseInitial));
+    const includeKeys = [...new Set(options?.onChange?.include ?? [])];
     const hasWatch = Boolean(options?.onChange?.handler) && includeKeys.length > 0;
-    const lastValues = new Map();
+    const lastSnapshots = new Map();
     let onChangeController = null;
     let onChangeRunId = 0;
     if (hasWatch) {
         includeKeys.forEach((key) => {
-            lastValues.set(key, data[key]);
+            lastSnapshots.set(key, cloneStateValue(data[key]));
         });
         $effect(() => {
             const changedKeys = [];
             includeKeys.forEach((key) => {
                 const nextValue = data[key];
-                if (!Object.is(lastValues.get(key), nextValue)) {
+                trackDeep(nextValue);
+                const nextSnapshot = cloneStateValue(nextValue);
+                if (!ObjectUtil.equals(lastSnapshots.get(key), nextSnapshot)) {
                     changedKeys.push(key);
-                    lastValues.set(key, nextValue);
+                    lastSnapshots.set(key, nextSnapshot);
                 }
             });
             if (!changedKeys.length)
@@ -33,7 +64,7 @@ export const createQuery = (initialValue, options) => {
                 await options.onChange.handler({
                     changedKeys,
                     signal: localController.signal,
-                    snapshot: ObjectUtil.deepClone(data)
+                    snapshot: cloneStateValue(data)
                 });
             };
             untrack(() => {
@@ -54,13 +85,13 @@ export const createQuery = (initialValue, options) => {
         });
     }
     const reset = () => {
-        data = ObjectUtil.deepClone(baseInitial);
+        data = cloneStateValue(baseInitial);
     };
     const patch = (value) => {
         data = { ...data, ...value };
     };
-    const snapshot = () => ObjectUtil.deepClone(data);
-    const initial = () => ObjectUtil.deepClone(baseInitial);
+    const snapshot = () => cloneStateValue(data);
+    const initial = () => cloneStateValue(baseInitial);
     return {
         get data() {
             return data;

package/dist/svelte/shared/cloneStateValue.d.ts

@@ -0,0 +1,2 @@
+/** Creates a detached graph from plain state while preserving opaque values. */
+export declare const cloneStateValue: <T>(value: T) => T;

package/dist/svelte/shared/cloneStateValue.js

@@ -0,0 +1,100 @@
+const preserveExtensibility = (source, target) => {
+    if (!Object.isExtensible(source))
+        Object.preventExtensions(target);
+};
+const cloneProperties = (source, target, seen, excluded) => {
+    for (const key of Reflect.ownKeys(source)) {
+        if (key === excluded)
+            continue;
+        const descriptor = Reflect.getOwnPropertyDescriptor(source, key);
+        if (!descriptor)
+            continue;
+        if ('value' in descriptor)
+            descriptor.value = cloneValue(descriptor.value, seen);
+        Reflect.defineProperty(target, key, descriptor);
+    }
+};
+const cloneValue = (value, seen) => {
+    if (value === null || typeof value !== 'object')
+        return value;
+    const cached = seen.get(value);
+    if (cached !== undefined)
+        return cached;
+    if (Array.isArray(value)) {
+        const result = new Array(value.length);
+        seen.set(value, result);
+        cloneProperties(value, result, seen, 'length');
+        const lengthDescriptor = Reflect.getOwnPropertyDescriptor(value, 'length');
+        if (lengthDescriptor)
+            Reflect.defineProperty(result, 'length', lengthDescriptor);
+        preserveExtensibility(value, result);
+        return result;
+    }
+    if (value instanceof Date) {
+        const result = new Date(value.getTime());
+        seen.set(value, result);
+        return result;
+    }
+    if (value instanceof Map) {
+        const result = new Map();
+        seen.set(value, result);
+        for (const [key, entryValue] of value) {
+            result.set(cloneValue(key, seen), cloneValue(entryValue, seen));
+        }
+        return result;
+    }
+    if (value instanceof Set) {
+        const result = new Set();
+        seen.set(value, result);
+        for (const entryValue of value)
+            result.add(cloneValue(entryValue, seen));
+        return result;
+    }
+    if (value instanceof RegExp) {
+        const result = new RegExp(value.source, value.flags);
+        result.lastIndex = value.lastIndex;
+        seen.set(value, result);
+        return result;
+    }
+    if (typeof URL !== 'undefined' && value instanceof URL) {
+        const result = new URL(value.href);
+        seen.set(value, result);
+        return result;
+    }
+    if (typeof URLSearchParams !== 'undefined' && value instanceof URLSearchParams) {
+        const result = new URLSearchParams(value);
+        seen.set(value, result);
+        return result;
+    }
+    if (value instanceof ArrayBuffer) {
+        const result = value.slice(0);
+        seen.set(value, result);
+        return result;
+    }
+    if (typeof SharedArrayBuffer !== 'undefined' && value instanceof SharedArrayBuffer) {
+        const result = value.slice(0);
+        seen.set(value, result);
+        return result;
+    }
+    if (ArrayBuffer.isView(value)) {
+        const buffer = cloneValue(value.buffer, seen);
+        const result = value instanceof DataView
+            ? new DataView(buffer, value.byteOffset, value.byteLength)
+            : new value.constructor(buffer, value.byteOffset, value.length);
+        seen.set(value, result);
+        return result;
+    }
+    const prototype = Object.getPrototypeOf(value);
+    if (prototype !== Object.prototype && prototype !== null) {
+        // File, Blob, Promise and class instances cannot be cloned generically without
+        // losing internal slots or behavior. Keeping them is lossless and preserves DX.
+        return value;
+    }
+    const result = Object.create(prototype);
+    seen.set(value, result);
+    cloneProperties(value, result, seen);
+    preserveExtensibility(value, result);
+    return result;
+};
+/** Creates a detached graph from plain state while preserving opaque values. */
+export const cloneStateValue = (value) => cloneValue(value, new WeakMap());

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@azure-net/kit",
-  "version": "5.1.1",
+  "version": "5.3.0",
   "license": "MIT",
   "author": "Pixel1917",
   "description": "Universal toolkit and library collection, developed as part of the Azure-net ecosystem",
@@ -73,15 +73,15 @@
     }
   },
   "peerDependencies": {
-    "@sveltejs/kit": ">=2.16.0",
-    "svelte": ">=5.0.0"
+    "@sveltejs/kit": ">=2.57.1",
+    "svelte": ">=5.55.4"
   },
   "devDependencies": {
     "@eslint/compat": "^2.0.5",
     "@eslint/js": "^10.0.1",
     "@playwright/test": "^1.59.1",
     "@sveltejs/adapter-auto": "^7.0.1",
-    "@sveltejs/kit": "^2.57.1",
+    "@sveltejs/kit": "^2.70.2",
     "@sveltejs/package": "^2.5.7",
     "@sveltejs/vite-plugin-svelte": "^7.0.0",
     "@testing-library/jest-dom": "^6.9.1",
@@ -95,7 +95,7 @@
     "prettier": "^3.8.3",
     "prettier-plugin-svelte": "^3.5.1",
     "publint": "^0.3.18",
-    "svelte": "^5.55.4",
+    "svelte": "^5.56.9",
     "svelte-check": "^4.4.6",
     "typescript": "^5.0.0",
     "typescript-eslint": "^8.58.2",
@@ -126,9 +126,10 @@
     "format": "prettier --write .",
     "lint": "prettier --check . && eslint .",
     "test:unit": "vitest --config vitest.config.ts",
+    "test:client": "vitest --config vitest.client.config.ts",
     "test:integration": "vitest --config vitest.integration.config.ts --run",
-    "test": "npm run test:unit -- --run && npm run test:e2e",
-    "test:e2e": "playwright test --pass-with-no-tests",
+    "test": "pnpm test:unit -- --run && pnpm test:client -- --run && pnpm test:integration && pnpm test:e2e",
+    "test:e2e": "playwright test",
     "commit": "pnpm format && git add ."
   }
 }