@azure-net/kit 5.1.0 → 5.2.0

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

@@ -15,6 +15,8 @@ export type CookieOptions = {
  * All methods are static and operate without creating instances.
  */
 export declare class UniversalCookie {
+    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

@@ -6,6 +6,36 @@ import { RequestContext } from '../../external/edges/ServerContext.js';
  * All methods are static and operate without creating instances.
  */
 export class UniversalCookie {
+    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 +47,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 +66,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 +87,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 +110,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 +119,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 +166,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/index.d.ts

@@ -1,7 +1,8 @@
 export { UniversalCookie, 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 { 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;
+            }
         }
-    }
+    });
 };