@azure-net/kit 6.0.0-next.7 → 6.0.0-next.9

package/README.md

@@ -14,7 +14,7 @@ must remain synchronous.
 
 The plugin provides virtual hooks only. It does not create or rewrite page/layout
 modules. Manual `hooks.server`, `hooks.client` and `hooks` files are forbidden.
-Initial Edges SSR state is hydrated once; later navigation is client-owned.
+Initial request state is hydrated once through Svelte hydratable; later navigation is client-owned.
 
 `program.ts` is universal: a static server-only import does not become safe merely
 because it is used inside `useServer`. Use an explicit build-time browser guard
@@ -195,12 +195,10 @@ export const { register } = createApp((app) =>
 	app
 		.useServer(async ({ event, resolve, useMiddlewares }) => {
 			await useMiddlewares([ServerAuth]);
-			await TranslationManager().preloadTranslation();
 			return resolve(event);
 		})
 		.useBoot(({ state }) => {
 			useCurrentUser().setUser(state.currentUser ?? null);
-			TranslationManager().syncFromState(state);
 		})
 );
 ```
@@ -229,7 +227,7 @@ script and serialization. No custom HTML parser is used by the kit.
 `createBoundaryProvider` is replaced by `CreateServiceContainer` (no compatibility alias):
 
 ```ts
-const ApplicationProvider = CreateDiContainer('ApplicationProvider', {
+const ApplicationProvider = CreateServiceContainer('ApplicationProvider', {
 	register: () => ({ Users: () => new UsersUseCases(repository) })
 });
 const { Users } = ApplicationProvider();
@@ -239,4 +237,139 @@ The accessor remains lazy, synchronous and request-scoped on SSR. `RegisterProvi
 registers an individual class factory; `singleton` means one browser instance but
 one instance per request on the server, never a server process singleton.
 
-Built-in i18n: see [I18N.md](./I18N.md). preloadTranslation() fills request state automatically; syncFromState(state) restores it synchronously in useBoot. No separate translation package, writable/derived stores or edges adapter is required.
+Built-in i18n: see [I18N.md](./I18N.md). Register a `new TranslationManager(options)` through `app.useTranslations(manager)`. Server preparation, locale hydration and client dictionary loading run automatically before the corresponding user hooks. No separate translation package or manual lifecycle calls are required.
+
+## AsyncSignal SSR Hydration
+
+Client-only signals remain synchronous. Opt into SSR with a stable, non-empty key:
+
+```svelte
+<script lang="ts">
+	import { createAsyncSignal } from '@azure-net/kit';
+
+	const result = await createAsyncSignal(() => loadProfile(), {
+		server: true,
+		key: 'profile:current-user'
+	});
+</script>
+
+<p>{result.response?.name}</p>
+<button onclick={() => result.refresh()}>Refresh</button>
+```
+
+Call this during component initialization with Svelte experimental async enabled.
+Svelte's `hydratable` transfers the initial serializable result to the browser,
+which reuses it without a duplicate request; later refreshes execute normally.
+There is no module-global server request state. The handler must work in both
+environments. Keys must match across SSR/hydration and distinguish request inputs.
+
+`beforeSend` runs only for actual requests; success/error callbacks and `ready`
+settlement apply on both sides. Request errors produce an error-state signal.
+`immediate: false` keeps the signal idle and disables initial hydration. Batch
+factories stay synchronous and explicitly reject `server: true` at type-check and
+runtime; use individually awaited server signals instead.
+
+See [AsyncSignal details](./src/lib/svelte/async-signal/README.md) for lifecycle,
+serialization, errors, cancellation, CSP, and batch behavior.
+
+## SvelteKit 3 hooks and class middleware
+
+Error callbacks use the native discriminated `CaughtError` contract from
+`@sveltejs/kit/hooks`. `status` and `message` are no longer added at the top level.
+For `kind: 'app'`, `'framework'` or `'validation'`, read `error.status` and
+`error.message`. For `kind: 'unknown'`, `error` remains `unknown`: narrow it before
+logging and do not return its potentially private message to clients. Validation
+issues are available only in the `'validation'` branch. Return `{ status, message }`
+to override the public response, or return nothing to retain SvelteKit defaults.
+The removed `handleValidationError` hook is not generated.
+
+```ts
+app.useServerError(({ kind, error, useLogger }) => {
+	if (kind === 'unknown') {
+		useLogger(error, {});
+		return { status: 500, message: 'Internal Error' };
+	}
+	return error;
+});
+```
+
+Middleware arrays now contain **constructors**, not functions or existing instances.
+Constructors must accept no required arguments. A fresh instance is constructed
+only when its turn is reached, on every request/navigation. Resolve dependencies
+inside that instance, not into module-level request-specific variables.
+
+```ts
+import type { IServerMiddleware, ServerMiddlewareContext, IClientMiddleware, ClientMiddlewareContext } from '@azure-net/kit';
+
+class ServerAuth implements IServerMiddleware {
+	async execute({ event, next }: ServerMiddlewareContext) {
+		if (!event.cookies.get('session')) return next('/login', 303);
+		next();
+	}
+}
+
+class ClientGuard implements IClientMiddleware {
+	execute({ next, to, navigation }: ClientMiddlewareContext): undefined {
+		if (navigation?.shallow) return next();
+		if (to.pathname === '/private') return next('/login', { replace: true });
+		return next();
+	}
+}
+
+app
+	.useServer(async ({ useMiddlewares, event, resolve }) => {
+		await useMiddlewares([ServerAuth]);
+		return resolve(event);
+	})
+	.useClient(({ useMiddlewares }) => {
+		useMiddlewares([ClientGuard]);
+	});
+```
+
+`IMiddleware<Context, Result>` is the common interface. Client `execute` is strictly
+synchronous (`undefined` return, normally `return next()`); server `execute` can
+return `void` or `Promise<void>`. Omitting `next()` blocks the chain. Neither the
+chain nor the container automatically disposes subscriptions owned by middleware:
+keep middleware short-lived and do not attach long-lived listeners there.
+
+Client `next(location, options)` and `useRedirect(...).clientRedirectSettings`
+use SvelteKit's `GotoOptions` directly: `replace`, `reset`, `refreshAll`, `shallow`,
+`persistState`, `state` and `invalidate`. Client navigation data includes the native
+`navigation` event. In Kit 3 shallow changes also trigger navigation hooks; choose
+explicitly whether a guard should skip them. `goto` is for app routes, not external
+URLs; external navigation should use browser location APIs.
+
+## CompositionRoot
+
+`CreateServiceContainer` remains unchanged. `CompositionRoot` is a lazy class
+facade over it, with a unique symbol as its internal container identity. It can be created at module
+scope; `resolve()` resolves against the current SSR request or browser
+cache, never a request captured by the constructor.
+
+```ts
+import { CompositionRoot } from '@azure-net/kit';
+
+export const Http = new CompositionRoot({
+	register: () => ({ Api: () => new ApiDatasource() })
+});
+
+export const Identity = new CompositionRoot({
+	dependsOn: { Http },
+	register: ({ Http }) => ({
+		Account: () => new AccountUseCases(new AccountRepository(Http.Api))
+	})
+});
+
+// Inside a presenter factory or an active request:
+const { Account } = Identity.resolve();
+```
+
+Dependencies accept both other `CompositionRoot` instances and existing
+`CreateServiceContainer` accessors. Service types are inferred through the chain.
+Only registration metadata is wrapped; there is no extra proxy around services
+and no new caching layer. Repeated resolution preserves existing container/service
+identity. If explicit cleanup is needed, use `await cleanupProvider(Identity.name)`.
+Declare roots once, rather than creating new roots per component render.
+`name` is now a symbol, not a serializable string. Its description is for diagnostics
+only; equal descriptions never share a cache. Existing string keys passed directly
+to `CreateServiceContainer` and `cleanupProvider` remain supported.

package/dist/i18n/Internal.d.ts

@@ -4,10 +4,12 @@ export interface TranslationLifecycle {
     syncFromState(state: App.RequestContextState): void;
     transformHtml(html: string): string;
 }
-declare const translationManager: unique symbol;
-export type TranslationManagerFactory = (() => object) & {
+export declare const translationManager: unique symbol;
+export interface TranslationManagerHandle {
     readonly [translationManager]: true;
-};
+}
+export type TranslationManagerFactory = (() => object) & TranslationManagerHandle;
+export type TranslationManagerSource = TranslationManagerFactory | TranslationManagerHandle;
 export declare const bindTranslationLifecycle: (manager: object, lifecycle: TranslationLifecycle) => void;
 export declare const getTranslationLifecycle: (manager: object) => TranslationLifecycle;
-export {};
+export declare const getTranslationManagerLifecycle: (manager: TranslationManagerSource) => TranslationLifecycle;

package/dist/i18n/Internal.js

@@ -5,6 +5,7 @@ export const bindTranslationLifecycle = (manager, lifecycle) => {
 export const getTranslationLifecycle = (manager) => {
     const lifecycle = lifecycles.get(manager);
     if (!lifecycle)
-        throw new Error('[AzureNetKit:i18n] Expected a manager returned by createTranslations().');
+        throw new Error('[AzureNetKit:i18n] Expected a TranslationManager or a manager returned by createTranslations().');
     return lifecycle;
 };
+export const getTranslationManagerLifecycle = (manager) => getTranslationLifecycle(typeof manager === 'function' ? manager() : manager);

package/dist/i18n/TranslationManager.d.ts

@@ -0,0 +1,19 @@
+import { createTranslations } from './Translations.svelte.js';
+import { type translationManager, type TranslationManagerHandle } from './Internal.js';
+import type { MessageLoader, Path, TranslationVariables } from './Types.js';
+export type TranslationManagerOptions<TMessages extends Record<string, MessageLoader>, TInitLocale extends Extract<keyof TMessages, string>> = Parameters<typeof createTranslations<TMessages, TInitLocale>>[0];
+/** A module-safe facade. Only the provider owns request-local reactive state. */
+export declare class TranslationManager<const TMessages extends Record<string, MessageLoader>, const TInitLocale extends Extract<keyof TMessages, string>> implements TranslationManagerHandle {
+    #private;
+    readonly [translationManager]: true;
+    constructor(options: TranslationManagerOptions<TMessages, TInitLocale>);
+    readonly t: (translation?: Path<Awaited<ReturnType<TMessages[TInitLocale]>>> | string | {
+        key: Path<Awaited<ReturnType<TMessages[TInitLocale]>>> | string;
+        vars?: TranslationVariables;
+    }, vars?: TranslationVariables) => string;
+    readonly switchLocale: (locale: Extract<keyof TMessages, string>) => Promise<void>;
+    readonly applyHtmlLocaleAttr: (html: string) => string;
+    readonly subscribeLocaleChangeEvent: (listener: (locale: Extract<keyof TMessages, string>) => void) => (() => void);
+    get locale(): Extract<keyof TMessages, string>;
+    get locales(): Readonly<Record<Extract<keyof TMessages, string>, Extract<keyof TMessages, string>>>;
+}

package/dist/i18n/TranslationManager.js

@@ -0,0 +1,26 @@
+import { createTranslations } from './Translations.svelte.js';
+import { bindTranslationLifecycle, getTranslationLifecycle } from './Internal.js';
+/** A module-safe facade. Only the provider owns request-local reactive state. */
+export class TranslationManager {
+    #factory;
+    constructor(options) {
+        this.#factory = createTranslations(options);
+        // Resolve on every lifecycle invocation, never capture a server request here.
+        bindTranslationLifecycle(this, {
+            preloadTranslation: () => getTranslationLifecycle(this.#factory()).preloadTranslation(),
+            initializeClient: () => getTranslationLifecycle(this.#factory()).initializeClient(),
+            syncFromState: (state) => getTranslationLifecycle(this.#factory()).syncFromState(state),
+            transformHtml: (html) => getTranslationLifecycle(this.#factory()).transformHtml(html)
+        });
+    }
+    t = (translation, vars) => this.#factory().t(translation, vars);
+    switchLocale = (locale) => this.#factory().switchLocale(locale);
+    applyHtmlLocaleAttr = (html) => this.#factory().applyHtmlLocaleAttr(html);
+    subscribeLocaleChangeEvent = (listener) => this.#factory().subscribeLocaleChangeEvent(listener);
+    get locale() {
+        return this.#factory().locale;
+    }
+    get locales() {
+        return this.#factory().locales;
+    }
+}

package/dist/i18n/index.d.ts

@@ -1,2 +1,3 @@
 export { createTranslations } from './Translations.svelte.js';
+export { TranslationManager, type TranslationManagerOptions } from './TranslationManager.js';
 export type { Translation, TranslationShape, TranslationSnapshot, TranslationCookieOptions, Path } from './Types.js';

package/dist/i18n/index.js

@@ -1 +1,2 @@
 export { createTranslations } from './Translations.svelte.js';
+export { TranslationManager } from './TranslationManager.js';

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

@@ -1,16 +1,16 @@
-import { type TranslationManagerFactory } from '../../i18n/Internal.js';
+import { type TranslationManagerSource } from '../../i18n/Internal.js';
 import { type ContextData } from '../../shared/request-context/Internal.js';
 import { AppError, type IAppError } from '../app-error/AppError.js';
 import { type AsyncHelperRetry } from '../app-error/ErrorRuntime.js';
-import { type IServerMiddleware } from './middleware/ServerMiddleware.js';
+import { type ServerMiddlewareClass } from './middleware/ServerMiddleware.js';
 import type { Handle, HandleFetch, HandleServerError, HandleClientError, Reroute, ServerInit, Transport } from '@sveltejs/kit/hooks';
 import type { RequestEvent } from '@sveltejs/kit';
-import { type IClientMiddleware } from './middleware/ClientMiddleware.js';
+import { type ClientMiddlewareClass } from './middleware/ClientMiddleware.js';
 import { useLogger } from '../logger/index.js';
 type MaybePromise<T> = T | Promise<T>;
 type HandleInput = Parameters<Handle>[0];
 type Resolve = HandleInput['resolve'];
-type BuilderFlags = Partial<Record<'useTranslations' | 'useBoot' | 'use' | 'useClient' | 'useClientInit' | 'useClientError' | 'useServerInit' | 'useServer' | 'useServerError' | 'useServerFetch' | 'useServerValidationError' | 'useAzureNetKitError' | 'useReroute' | 'useTransport', true>>;
+type BuilderFlags = Partial<Record<'useTranslations' | 'useBoot' | 'use' | 'useClient' | 'useClientInit' | 'useClientError' | 'useServerInit' | 'useServer' | 'useServerError' | 'useServerFetch' | 'useAzureNetKitError' | 'useReroute' | 'useTransport', true>>;
 type WithFlag<TFlags extends BuilderFlags, TKey extends keyof BuilderFlags> = TFlags & Record<TKey, true>;
 type OnceMethod<TFlags extends BuilderFlags, TKey extends keyof BuilderFlags, TMethod> = TFlags[TKey] extends true ? object : TMethod;
 export interface AppUniversalLifecycleContext {
@@ -20,24 +20,19 @@ export interface AppUniversalLifecycleContext {
     event?: RequestEvent;
 }
 export interface AppClientLifecycleContext {
-    useMiddlewares: (middlewares: IClientMiddleware[]) => void;
+    useMiddlewares: (middlewares: readonly ClientMiddlewareClass[]) => void;
 }
 export type AppClientInitLifecycleContext = void;
-export type AppClientErrorContext = Parameters<HandleClientError>[0] & {
-    status: number;
-    message: string;
-};
+export type AppClientErrorContext = Parameters<HandleClientError>[0];
 export type AppServerInitLifecycleContext = void;
 export interface AppServerLifecycleContext {
     requestContext: ContextData;
     event: RequestEvent;
     resolve: Resolve;
-    useMiddlewares: (middlewares: IServerMiddleware[]) => Promise<void>;
+    useMiddlewares: (middlewares: readonly ServerMiddlewareClass[]) => Promise<void>;
 }
 export type AppServerErrorContext = Parameters<HandleServerError>[0] & {
     requestContext: ContextData;
-    status: number;
-    message: string;
     useLogger: typeof useLogger;
 };
 export type AppServerFetchContext = Parameters<HandleFetch>[0] & {
@@ -68,7 +63,7 @@ export type AppBootCallback = (context: AppBootContext) => undefined;
 export type CreateAppBuilder<TFlags extends BuilderFlags = object> = OnceMethod<TFlags, 'useBoot', {
     useBoot(callback: AppBootCallback): CreateAppBuilder<WithFlag<TFlags, 'useBoot'>>;
 }> & OnceMethod<TFlags, 'useTranslations', {
-    useTranslations(manager: TranslationManagerFactory): CreateAppBuilder<WithFlag<TFlags, 'useTranslations'>>;
+    useTranslations(manager: TranslationManagerSource): CreateAppBuilder<WithFlag<TFlags, 'useTranslations'>>;
 }> & OnceMethod<TFlags, 'use', {
     use(callback: AppUniversalLifecycleCallback): CreateAppBuilder<WithFlag<TFlags, 'use'>>;
 }> & OnceMethod<TFlags, 'useClient', {

package/dist/shared/app/App.js

@@ -1,4 +1,4 @@
-import { getTranslationLifecycle } from '../../i18n/Internal.js';
+import { getTranslationManagerLifecycle } from '../../i18n/Internal.js';
 import { hydratable } from 'svelte';
 import { getContextInternals } from '../../shared/request-context/Internal.js';
 import { BROWSER } from '../../external/tools/index.js';
@@ -9,15 +9,6 @@ import { executeServerMiddlewares } from './middleware/ServerMiddleware.js';
 import { beforeNavigate } from '$app/navigation';
 import { executeClientMiddlewares } from './middleware/ClientMiddleware.js';
 import { useLogger } from '../logger/index.js';
-// Kit 3 nests safe status/message inside caught errors; unknown errors keep safe defaults.
-const errorDetails = (input) => {
-    const legacy = input;
-    const error = input.kind !== 'unknown' && input.error && typeof input.error === 'object' ? input.error : {};
-    return {
-        status: typeof legacy.status === 'number' ? legacy.status : typeof error.status === 'number' ? error.status : 500,
-        message: typeof legacy.message === 'string' ? legacy.message : typeof error.message === 'string' ? error.message : 'Internal Error'
-    };
-};
 const clientLifecycleFlags = new WeakMap();
 const getRequestContext = () => {
     try {
@@ -162,7 +153,7 @@ export const createApp = (callback) => {
             };
             if (!callbacks.useTranslations)
                 return initialize();
-            translationInitPromise = getTranslationLifecycle(callbacks.useTranslations())
+            translationInitPromise = getTranslationManagerLifecycle(callbacks.useTranslations)
                 .initializeClient()
                 .then(initialize)
                 .catch((error) => {
@@ -192,7 +183,6 @@ export const createApp = (callback) => {
         return serverInitPromise;
     };
     const runServerError = (input) => {
-        const { status, message } = errorDetails(input);
         if (BROWSER)
             return undefined;
         const requestContext = getServerRequestContext();
@@ -201,8 +191,6 @@ export const createApp = (callback) => {
             const result = callbacks.useServerError?.({
                 requestContext,
                 ...input,
-                status,
-                message,
                 useLogger
             });
             if (result && typeof result.then === 'function') {
@@ -217,14 +205,11 @@ export const createApp = (callback) => {
         }
     };
     const runClientError = (input) => {
-        const { status, message } = errorDetails(input);
         if (!BROWSER)
             return undefined;
         bindErrorResolver();
         return callbacks.useClientError?.({
-            ...input,
-            status,
-            message
+            ...input
         });
     };
     const runServerFetch = (input) => {
@@ -237,7 +222,7 @@ export const createApp = (callback) => {
     };
     const reroute = (input) => callbacks.useReroute?.(input);
     const handle = async ({ event, resolve: originalResolve }) => {
-        const translations = callbacks.useTranslations ? getTranslationLifecycle(callbacks.useTranslations()) : undefined;
+        const translations = callbacks.useTranslations ? getTranslationManagerLifecycle(callbacks.useTranslations) : undefined;
         const resolve = translations
             ? (event, options) => originalResolve(event, {
                 ...options,
@@ -285,7 +270,7 @@ export const createApp = (callback) => {
         flags.boot = true;
         const state = hydratable('@azure-net/kit:initial-state:v1', () => (BROWSER ? {} : RequestContext.current().state));
         if (callbacks.useTranslations)
-            getTranslationLifecycle(callbacks.useTranslations()).syncFromState(state);
+            getTranslationManagerLifecycle(callbacks.useTranslations).syncFromState(state);
         const result = callbacks.useBoot?.({ state });
         if (result && typeof result.then === 'function') {
             void Promise.resolve(result).catch(() => undefined);

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

@@ -1,5 +1,6 @@
 export { createApp, type AppAzureNetKitErrorCallback, type AppAzureNetKitErrorContext, type AppClientErrorCallback, type AppClientErrorContext, type AppClientInitLifecycleCallback, type AppClientInitLifecycleContext, type AppClientLifecycleCallback, type AppClientLifecycleContext, type AppRegistrar, type AppServerErrorCallback, type AppServerErrorContext, type AppServerFetchCallback, type AppServerFetchContext, type AppServerInitLifecycleCallback, type AppServerInitLifecycleContext, type AppServerLifecycleCallback, type AppServerLifecycleContext, 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 { IClientMiddleware, ClientMiddlewareContext, ClientMiddlewareClass } from './middleware/ClientMiddleware.js';
+export type { IServerMiddleware, ServerMiddlewareContext, ServerMiddlewareClass } from './middleware/ServerMiddleware.js';
+export type { IMiddleware, MiddlewareClass } from './middleware/Types.js';
 export type { EnsureRoute, EnsureRouteSource, EnsureRouteTarget } from './middleware/Shared.js';
 export type { AppBootContext, AppBootCallback } from './App.js';

package/dist/shared/app/middleware/ClientMiddleware.d.ts

@@ -1,10 +1,16 @@
 import { type EnsureRoute } from './Shared.js';
-import type { RedirectStatus } from '../../../svelte/redirect/index.js';
-import type { BeforeNavigate } from '$app/navigation';
-export type IClientMiddleware = (middlewareData: {
-    to: URL;
-    from?: URL;
-    next: (location?: string | URL, status?: RedirectStatus) => undefined;
+import type { BeforeNavigate, GotoOptions } from '$app/navigation';
+import type { ReadonlyURL } from '$app/state';
+import type { IMiddleware, MiddlewareClass } from './Types.js';
+export interface ClientMiddlewareContext {
+    to: ReadonlyURL;
+    from?: ReadonlyURL;
+    navigation?: BeforeNavigate;
+    next: (location?: string | URL, options?: GotoOptions) => undefined;
     ensureRoute: EnsureRoute;
-}) => undefined;
-export declare const executeClientMiddlewares: (middlewares: IClientMiddleware[], navigation?: BeforeNavigate) => void;
+}
+export interface IClientMiddleware extends IMiddleware<ClientMiddlewareContext, undefined> {
+    execute(context: ClientMiddlewareContext): undefined;
+}
+export type ClientMiddlewareClass = MiddlewareClass<IClientMiddleware>;
+export declare const executeClientMiddlewares: (middlewares: readonly ClientMiddlewareClass[], navigation?: BeforeNavigate) => void;

package/dist/shared/app/middleware/ClientMiddleware.js

@@ -3,24 +3,46 @@ import { page } from '$app/state';
 import { goto } from '$app/navigation';
 export const executeClientMiddlewares = (middlewares, navigation) => {
     const from = navigation?.from?.url ?? undefined;
-    const to = navigation?.to?.url ?? page?.url;
+    const to = navigation?.to?.url ?? page.url;
     for (const middleware of middlewares) {
         let shouldContinue = false;
         let redirectTo;
-        const next = (location) => {
+        let redirectOptions;
+        let active = true;
+        const next = (location, options) => {
+            if (!active)
+                throw new Error('[Middleware] next() must be called synchronously and only once.');
+            active = false;
             shouldContinue = true;
             redirectTo = location;
+            redirectOptions = options;
             return undefined;
         };
-        middleware({
-            to,
-            from,
-            next,
-            ensureRoute
-        });
-        if (redirectTo) {
+        let result;
+        try {
+            result = new middleware().execute({
+                to,
+                from,
+                next,
+                ensureRoute,
+                navigation
+            });
+        }
+        catch (error) {
+            navigation?.cancel();
+            throw error;
+        }
+        finally {
+            active = false;
+        }
+        if (result && typeof result.then === 'function') {
+            navigation?.cancel();
+            void Promise.resolve(result).catch(() => undefined);
+            throw new Error('[Middleware] Client execute() must be synchronous.');
+        }
+        if (redirectTo !== undefined) {
             navigation?.cancel();
-            void goto(redirectTo);
+            void goto(redirectTo, redirectOptions).catch((error) => console.error('[Middleware] Redirect failed:', error));
             return;
         }
         if (!shouldContinue) {

package/dist/shared/app/middleware/ServerMiddleware.d.ts

@@ -1,11 +1,16 @@
 import { type RequestEvent } from '@sveltejs/kit';
 import { type EnsureRoute } from './Shared.js';
 import type { RedirectStatus } from '../../../svelte/redirect/index.js';
-export type IServerMiddleware = (middlewareData: {
+import type { IMiddleware, MiddlewareClass } from './Types.js';
+export interface ServerMiddlewareContext {
     to: RequestEvent['url'];
     from?: RequestEvent['url'];
     next: (location?: string | URL, status?: RedirectStatus) => void;
-    event?: RequestEvent;
+    event: RequestEvent;
     ensureRoute: EnsureRoute;
-}) => Promise<void> | void;
-export declare const executeServerMiddlewares: (middlewares: IServerMiddleware[]) => Promise<void>;
+}
+export interface IServerMiddleware extends IMiddleware<ServerMiddlewareContext, Promise<void> | void> {
+    execute(context: ServerMiddlewareContext): Promise<void> | void;
+}
+export type ServerMiddlewareClass = MiddlewareClass<IServerMiddleware>;
+export declare const executeServerMiddlewares: (middlewares: readonly ServerMiddlewareClass[]) => Promise<void>;

package/dist/shared/app/middleware/ServerMiddleware.js

@@ -7,7 +7,7 @@ export const executeServerMiddlewares = async (middlewares) => {
         const event = RequestContext.current().event;
         if (event) {
             const referer = event?.request.headers.get('referer');
-            const from = referer ? new URL(referer) : undefined;
+            const from = referer && URL.canParse(referer) ? new URL(referer) : undefined;
             const to = event?.url;
             for (const middleware of middlewares) {
                 let shouldContinue = false;
@@ -17,7 +17,7 @@ export const executeServerMiddlewares = async (middlewares) => {
                         return redirect(status, location);
                     }
                 };
-                await middleware({
+                await new middleware().execute({
                     event,
                     to,
                     from,

package/dist/shared/app/middleware/Types.d.ts

@@ -0,0 +1,4 @@
+export interface IMiddleware<TContext, TResult = void> {
+    execute(context: TContext): TResult;
+}
+export type MiddlewareClass<T> = new () => T;

package/dist/shared/app/middleware/Types.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,21 @@
+import { type ProviderSettings, type ProviderWithType } from './Provider.js';
+type Services = Record<string, () => unknown>;
+type Dependency = ProviderWithType<Services> | {
+    readonly resolve: ProviderWithType<Services>;
+};
+type Dependencies = Record<string, Dependency>;
+type Providers<D extends Dependencies> = {
+    [K in keyof D]: D[K] extends {
+        readonly resolve: infer P extends ProviderWithType<Services>;
+    } ? P : D[K] extends ProviderWithType<Services> ? D[K] : never;
+};
+export type CompositionRootSettings<T extends Services, D extends Dependencies = Record<never, never>> = Omit<ProviderSettings<T, Providers<D>>, 'dependsOn'> & {
+    dependsOn?: D;
+};
+/** Holds registration metadata only. Resolving always uses the current request's container. */
+export declare class CompositionRoot<T extends Services, D extends Dependencies = Record<never, never>> {
+    readonly name: symbol;
+    readonly resolve: ProviderWithType<T>;
+    constructor(settings: CompositionRootSettings<T, D>);
+}
+export {};

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

@@ -0,0 +1,11 @@
+import { CreateServiceContainer } from './Provider.js';
+const toProvider = (dependency) => typeof dependency === 'function' ? dependency : dependency.resolve;
+/** Holds registration metadata only. Resolving always uses the current request's container. */
+export class CompositionRoot {
+    name = Symbol('@azure-net/kit:CompositionRoot');
+    resolve;
+    constructor(settings) {
+        const dependsOn = Object.fromEntries(Object.entries(settings.dependsOn ?? {}).map(([key, dependency]) => [key, toProvider(dependency)]));
+        this.resolve = CreateServiceContainer(this.name, { ...settings, dependsOn });
+    }
+}

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

@@ -1,3 +1,4 @@
+export type ProviderKey = string | symbol;
 type ServiceFactory<T> = () => T;
 type ServiceMap = Record<string, ServiceFactory<unknown>>;
 type ResolvedServices<T extends ServiceMap> = {
@@ -16,6 +17,6 @@ export interface ProviderSettings<T extends ServiceMap, D extends Record<string,
     boot?: (services: ResolvedServices<T>) => undefined;
     register: ProviderFactory<T, D>;
 }
-export declare const CreateServiceContainer: <T extends ServiceMap, D extends Record<string, ProviderWithType<ServiceMap>>>(name: string, settings: ProviderSettings<T, D>) => ProviderWithType<T>;
-export declare function cleanupProvider(name: string): Promise<void>;
+export declare const CreateServiceContainer: <T extends ServiceMap, D extends Record<string, ProviderWithType<ServiceMap>>>(name: ProviderKey, settings: ProviderSettings<T, D>) => ProviderWithType<T>;
+export declare function cleanupProvider(name: ProviderKey): Promise<void>;
 export {};

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

@@ -67,19 +67,20 @@ const getConstructionStack = () => {
     const context = RequestContext.current();
     return (getContextInternals(context).boundaryProviderConstructionStack ??= []);
 };
-const runWithCycleGuard = (key, callback) => {
+const runWithCycleGuard = (provider, member, callback) => {
     const stack = getConstructionStack();
-    if (stack.includes(key)) {
-        const cycleStart = stack.indexOf(key);
-        const cyclePath = [...stack.slice(cycleStart), key].join(' -> ');
+    const cycleStart = stack.findIndex((entry) => entry.provider === provider && entry.member === member);
+    const entry = { provider, member };
+    if (cycleStart !== -1) {
+        const cyclePath = [...stack.slice(cycleStart), entry].map(({ provider, member }) => `${String(provider)}.${member}`).join(' -> ');
         throw new AzureNetKitInternalError(`[BoundaryProvider] Circular provider dependency detected: ${cyclePath}`);
     }
-    stack.push(key);
+    stack.push(entry);
     try {
         return callback();
     }
     finally {
-        const idx = stack.lastIndexOf(key);
+        const idx = stack.lastIndexOf(entry);
         if (idx !== -1)
             stack.splice(idx, 1);
     }
@@ -109,7 +110,7 @@ export const CreateServiceContainer = (name, settings) => {
                     }
                 });
             }
-            factories = runWithCycleGuard(`${name}.register`, () => register(deps));
+            factories = runWithCycleGuard(name, 'register', () => register(deps));
             return factories;
         };
         const providerProxy = new Proxy({}, {
@@ -125,15 +126,15 @@ export const CreateServiceContainer = (name, settings) => {
                         return undefined;
                     if (Reflect.has(target, key))
                         return Reflect.get(target, key, receiver);
-                    throw new AzureNetKitInternalError(`[BoundaryProvider] Service '${key}' not found in provider '${name}'`);
+                    throw new AzureNetKitInternalError(`[BoundaryProvider] Service '${key}' not found in provider '${String(name)}'`);
                 }
                 const factory = factories[key];
                 if (typeof factory !== 'function') {
                     throw new AzureNetKitInternalError('[BoundaryProvider] Factory must be a function');
                 }
-                const instance = runWithCycleGuard(`${name}.${key}`, () => factory());
+                const instance = runWithCycleGuard(name, key, () => factory());
                 if (instance && typeof instance?.then === 'function') {
-                    throw new AzureNetKitInternalError(`[BoundaryProvider] Service '${key}' in provider '${name}' returned Promise.`);
+                    throw new AzureNetKitInternalError(`[BoundaryProvider] Service '${key}' in provider '${String(name)}' returned Promise.`);
                 }
                 cache.set(key, instance);
                 return instance;
@@ -172,7 +173,7 @@ export const CreateServiceContainer = (name, settings) => {
                 const bootResult = boot(providerProxy);
                 if (bootResult && typeof bootResult.then === 'function') {
                     void Promise.resolve(bootResult).catch(() => undefined);
-                    throw new AzureNetKitInternalError(`[BoundaryProvider] Boot for provider '${name}' must be synchronous.`);
+                    throw new AzureNetKitInternalError(`[BoundaryProvider] Boot for provider '${String(name)}' must be synchronous.`);
                 }
                 setBootFlag(name, true);
             }
@@ -192,10 +193,10 @@ export async function cleanupProvider(name) {
             if (service && typeof service === 'object' && 'dispose' in service) {
                 try {
                     const disposeResult = service.dispose();
-                    promises.push(Promise.resolve(disposeResult).catch((err) => console.error(`Error disposing ${name}.${key}:`, err)));
+                    promises.push(Promise.resolve(disposeResult).catch((err) => console.error(`Error disposing ${String(name)}.${key}:`, err)));
                 }
                 catch (err) {
-                    console.error(`Error disposing ${name}.${key}:`, err);
+                    console.error(`Error disposing ${String(name)}.${key}:`, err);
                 }
             }
         }

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

@@ -1 +1,2 @@
 export * from './Provider.js';
+export { CompositionRoot, type CompositionRootSettings } from './CompositionRoot.js';

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

@@ -1 +1,2 @@
 export * from './Provider.js';
+export { CompositionRoot } from './CompositionRoot.js';

package/dist/shared/index.d.ts

@@ -1,6 +1,7 @@
 export { UniversalCookie, UniversalCookieInstance, UniversalNamedCookieInstance, type CookieOptions } from './cookie/index.js';
 export { BackgroundTask } from './background-task/index.js';
 export { ClassMirror } from './class-mirror/index.js';
-export { CreateServiceContainer, cleanupProvider, type ProviderSettings } from './boundary-provider/index.js';
+export { CreateServiceContainer, cleanupProvider, type ProviderSettings, type ProviderKey } from './boundary-provider/index.js';
+export { CompositionRoot, type CompositionRootSettings } from './boundary-provider/index.js';
 export * from './app/index.js';
 export { useLogger, LoggerErrors, type ILoggerError, type ILoggerSettings } from './logger/index.js';

package/dist/shared/index.js

@@ -2,5 +2,6 @@ export { UniversalCookie, UniversalCookieInstance, UniversalNamedCookieInstance
 export { BackgroundTask } from './background-task/index.js';
 export { ClassMirror } from './class-mirror/index.js';
 export { CreateServiceContainer, cleanupProvider } from './boundary-provider/index.js';
+export { CompositionRoot } from './boundary-provider/index.js';
 export * from './app/index.js';
 export { useLogger, LoggerErrors } from './logger/index.js';

package/dist/svelte/async-signal/AsyncSignal.svelte.d.ts

@@ -1,7 +1,6 @@
 export type AsyncStatus = 'idle' | 'pending' | 'success' | 'error';
 export type AsyncSignalSource = 'auto' | 'manual' | 'global';
-export interface AsyncSignalOptions<TData, TError = Error> {
-    server?: boolean;
+interface AsyncSignalBaseOptions<TData, TError = Error> {
     immediate?: boolean;
     initialData?: TData | (() => TData);
     beforeSend?: (meta: {
@@ -12,6 +11,15 @@ export interface AsyncSignalOptions<TData, TError = Error> {
     onError?: (error: TError) => void | Promise<void>;
     key?: string;
 }
+export type AsyncSignalOptions<TData, TError = Error> = AsyncSignalBaseOptions<TData, TError> & ({
+    server: true;
+    key: string;
+} | {
+    server?: false;
+});
+type AsyncSignalBatchSignalOptions<TData, TError> = Omit<AsyncSignalBaseOptions<TData, TError>, 'immediate'> & {
+    server?: false;
+};
 export interface AsyncSignalSvelte<TData, TError = Error> {
     response?: TData;
     error?: TError;
@@ -27,13 +35,21 @@ export interface AsyncSignalBatchOptions {
     parallel?: boolean;
 }
 export interface AsyncSignalBatchFactory {
-    <TData, TError = Error>(handler: (signal?: AbortSignal) => Promise<TData>, options?: Omit<AsyncSignalOptions<TData, TError>, 'immediate'>): AsyncSignalSvelte<TData, TError>;
+    <TData, TError = Error>(handler: (signal?: AbortSignal) => Promise<TData>, options?: AsyncSignalBatchSignalOptions<TData, TError>): AsyncSignalSvelte<TData, TError>;
 }
 export interface AsyncSignalBatch<TSignals extends readonly AsyncSignalSvelte<unknown, unknown>[]> {
     execute: () => TSignals;
 }
 export declare const isAsyncSignalScheduledForClient: (signal: AsyncSignalSvelte<unknown, unknown>) => boolean;
-export declare const createAsyncSignal: <TData, TError = Error>(handler: (signal?: AbortSignal) => Promise<TData>, options?: AsyncSignalOptions<TData, TError>) => AsyncSignalSvelte<TData, TError>;
+export declare function createAsyncSignal<TData, TError = Error>(handler: (signal?: AbortSignal) => Promise<TData>, options: AsyncSignalBaseOptions<TData, TError> & {
+    server: true;
+    key: string;
+}): Promise<AsyncSignalSvelte<TData, TError>>;
+export declare function createAsyncSignal<TData, TError = Error>(handler: (signal?: AbortSignal) => Promise<TData>, options?: AsyncSignalBaseOptions<TData, TError> & {
+    server?: false;
+}): AsyncSignalSvelte<TData, TError>;
+export declare function createAsyncSignal<TData, TError = Error>(handler: (signal?: AbortSignal) => Promise<TData>, options: AsyncSignalOptions<TData, TError>): AsyncSignalSvelte<TData, TError> | Promise<AsyncSignalSvelte<TData, TError>>;
 export declare const createAsyncSignalBatch: <const TSignals extends readonly AsyncSignalSvelte<unknown, unknown>[]>(factory: (createSignal: AsyncSignalBatchFactory) => TSignals, options?: AsyncSignalBatchOptions) => AsyncSignalBatch<TSignals>;
 export declare const refreshAsyncSignal: (key: string) => Promise<void>;
 export declare const refreshAllAsyncSignals: () => Promise<void>;
+export {};

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

@@ -1,4 +1,4 @@
-import { untrack } from 'svelte';
+import { hydratable, untrack } from 'svelte';
 import { BROWSER } from '../../external/tools/index.js';
 const ASYNC_SIGNAL_BATCH_INTERNAL = Symbol('async-signal-batch-internal');
 const ASYNC_SIGNAL_SCHEDULED_FOR_CLIENT = Symbol('async-signal-scheduled-for-client');
@@ -60,7 +60,14 @@ const createAsyncSignalManager = () => {
     return { refreshAll, refreshByKey, generateKey, register, unregister };
 };
 const asyncSignalManager = createAsyncSignalManager();
-export const createAsyncSignal = (handler, options = {}) => {
+export function createAsyncSignal(handler, options = {}) {
+    if (options.server && (typeof options.key !== 'string' || !options.key.trim())) {
+        throw new Error('[AsyncSignal] server: true requires a stable, non-empty key.');
+    }
+    const signal = createAsyncSignalInstance(handler, options, options.server && options.immediate !== false ? options.key : undefined);
+    return options.server ? signal.ready.then(() => signal) : signal;
+}
+const createAsyncSignalInstance = (handler, options = {}, hydrationKey) => {
     const { server = false, immediate = true, initialData = undefined, key } = options;
     const resolvedInitialData = typeof initialData === 'function' ? initialData() : initialData;
     let scheduledForClient = immediate && !BROWSER && !server;
@@ -105,15 +112,43 @@ export const createAsyncSignal = (handler, options = {}) => {
         status = 'pending';
         error = undefined;
         try {
-            if (options.beforeSend) {
-                const beforeSendResult = options.beforeSend({ initial, source });
-                if (beforeSendResult && typeof beforeSendResult.then === 'function')
-                    await beforeSendResult;
+            const request = async () => {
+                if (options.beforeSend) {
+                    const beforeSendResult = options.beforeSend({ initial, source });
+                    if (beforeSendResult && typeof beforeSendResult.then === 'function')
+                        await beforeSendResult;
+                }
+                if (runId !== currentRunId || abortController !== localController || localController.signal.aborted) {
+                    return undefined;
+                }
+                return handler(localController.signal);
+            };
+            let result;
+            if (initial && hydrationKey !== undefined) {
+                let originalError;
+                // Call before yielding: hydratable needs the component's active render context.
+                const outcome = await hydratable(`@azure-net/kit/async-signal:${hydrationKey}`, async () => {
+                    try {
+                        return { ok: true, data: await request() };
+                    }
+                    catch (error) {
+                        originalError = { value: error };
+                        // Error instances are not devalue-serializable; do not expose server stacks.
+                        return error instanceof Error
+                            ? { ok: false, native: true, error: { name: error.name, message: error.message } }
+                            : { ok: false, native: false, error };
+                    }
+                });
+                if (!outcome.ok) {
+                    if (originalError)
+                        throw originalError.value;
+                    throw outcome.native ? Object.assign(new Error(outcome.error.message), { name: outcome.error.name }) : outcome.error;
+                }
+                result = outcome.data;
             }
-            if (runId !== currentRunId || abortController !== localController || localController.signal.aborted) {
-                return undefined;
+            else {
+                result = await request();
             }
-            const result = await handler(localController.signal);
             if (runId !== currentRunId || abortController !== localController || localController.signal.aborted) {
                 return undefined;
             }
@@ -183,21 +218,26 @@ export const createAsyncSignal = (handler, options = {}) => {
     if (BROWSER) {
         const signalKey = key ?? asyncSignalManager.generateKey();
         const callback = (source) => startWhenUnlocked(source);
-        asyncSignalManager.register(signalKey, callback);
+        if (hydrationKey === undefined)
+            asyncSignalManager.register(signalKey, callback);
         $effect(() => {
+            // Async component initialization may be abandoned before this effect runs.
+            if (hydrationKey !== undefined)
+                asyncSignalManager.register(signalKey, callback);
             return () => {
                 asyncSignalManager.unregister(signalKey, callback);
             };
         });
     }
     if (immediate) {
+        // Automatic runs have no caller to catch a rejected onError callback.
         if (!BROWSER && server) {
             untrack(() => {
-                void start('auto');
+                void start('auto').catch(() => undefined);
             });
         }
         else if (BROWSER) {
-            void start('auto');
+            void start('auto').catch(() => undefined);
         }
     }
     const asyncSignal = {
@@ -272,7 +312,10 @@ export const createAsyncSignal = (handler, options = {}) => {
 export const createAsyncSignalBatch = (factory, options = {}) => {
     const internals = new Map();
     const createSignal = (handler, signalOptions = {}) => {
-        const signal = createAsyncSignal(handler, { ...signalOptions, immediate: false });
+        if (signalOptions.server) {
+            throw new Error('[AsyncSignalBatch] server: true is not supported. Await createAsyncSignal during component initialization instead.');
+        }
+        const signal = createAsyncSignalInstance(handler, { ...signalOptions, immediate: false });
         const internal = signal[ASYNC_SIGNAL_BATCH_INTERNAL];
         internal.lock();
         internals.set(signal, internal);

package/dist/svelte/async-signal/README.md

@@ -0,0 +1,89 @@
+# AsyncSignal server hydration
+
+`createAsyncSignal(handler)` and `{ server: false }` return a signal synchronously,
+with the existing client-only automatic execution behavior. With `{ server: true }`,
+the return type is `Promise<AsyncSignalSvelte<T>>`; await it to obtain the settled
+initial signal on both the server and the browser.
+
+```svelte
+<script lang="ts">
+	import { createAsyncSignal } from '@azure-net/kit';
+
+	let { api } = $props<{
+		api: { getProfile(signal?: AbortSignal): Promise<{ name: string }> };
+	}>();
+
+	const profile = await createAsyncSignal((signal) => api.getProfile(signal), {
+		server: true,
+		key: 'profile:current-user'
+	});
+</script>
+
+<p>{profile.response?.name}</p>
+<button onclick={() => profile.refresh()}>Refresh</button>
+```
+
+Enable Svelte's `compilerOptions.experimental.async`. Call the factory during
+component initialization, directly in the component script as above, or through a
+synchronous helper called there. Do not first await inside an ordinary async helper,
+or create a server-hydratable signal in a module singleton, event handler, `onMount`,
+or `$effect`: Svelte needs the active component render context when `hydratable` is
+called. The request handler itself may await normally. Supply a handler that can run
+in both environments. In this example the parent supplies an API service created
+for the current SSR request, and independently creates its browser counterpart.
+Do not serialize the service through `load` data. Its server implementation must
+capture the current request's fetch/auth context, or use an absolute trusted API
+URL with explicitly scoped credentials. Global server `fetch('/api/profile')`
+cannot resolve a relative URL, and `credentials: 'include'` does not automatically
+forward the incoming user's cookies on the server. Forward only the credentials
+needed by a trusted destination; never put them in the hydration payload.
+
+The key must be non-empty, stable between SSR and hydration, and unique for each
+logically distinct request in a render (include parameters when relevant). The
+library namespaces it. Svelte owns the per-render payload; AsyncSignal does not add
+a shared server request cache. This does not make module-global services, mutable
+handler state, or publicly cached personalized HTML safe: the application must
+keep those request-scoped or otherwise isolate users.
+Data and non-Error rejection values must be serializable by
+Svelte's `hydratable`/devalue. Native errors transfer their name and message, not
+stack traces, subclasses, or custom properties. Do not return secrets or sensitive
+error messages: hydratable payloads are sent to the browser.
+
+Only the initial automatic request is hydratable. Hydration reuses its result
+without invoking the handler or `beforeSend`; `onSuccess`/`onError` run for the
+settled result in each environment, and `ready` waits for those callbacks. An
+initial request failure yields a signal with `status: 'error'`, as before, rather
+than rejecting the factory promise. Subsequent `execute`, `refresh`, and global
+refreshes use normal request, cancellation, callback, and ready-cycle behavior.
+`beforeSend` sees `initial: false` on a refresh after hydration.
+
+If `onSuccess` throws, the signal enters the error state and invokes `onError`,
+retaining the loaded response. If `onError` also throws, `ready` still settles;
+explicit `execute`/`refresh` reject with that callback error, while automatic
+initial loading consumes it to avoid an unhandled rejection. The signal's `error`
+retains the original request or success-callback failure. Hydratable signals join
+the browser global-refresh registry only when their component effect runs, so an
+initialization abandoned before mounting leaves no registry entry. Unmounting is
+not equivalent to calling `abort`: already-running handlers/callbacks may finish.
+
+`initialData` (or its synchronous factory) initializes `response` independently in
+each environment. It does not skip the automatic request or change an idle signal
+to success. With `server: true` and the default `immediate: true`, the factory still
+awaits initial loading; success replaces the fallback, while failure retains it.
+Only the request outcome is transferred, not `initialData`, so use matching fallback
+values on the server and browser to avoid hydration mismatches after a failure.
+
+`immediate: false` disables initial loading and hydration, including in server mode:
+`await createAsyncSignal(handler, { server: true, key: 'profile', immediate: false,
+initialData })` returns an idle signal whose `response` and resolved `ready` contain
+the initial value (or `undefined` if omitted). The key is still required. Later
+explicit execution is ordinary, non-hydratable work.
+
+Batch factories remain synchronous and deferred;
+`createAsyncSignalBatch` explicitly rejects `server: true` in its factory at both
+type-check and runtime. Use individually awaited server signals instead. Ordinary
+batches preserve locks, parallel/sequential execution, cancellation, and ready gates.
+
+Outside SvelteKit, include both `head` and `body` returned by `await render(...)` in
+the document: Svelte places the hydration payload in `head`. Configure a CSP nonce
+or hash through Svelte's render options if your application uses CSP.

package/dist/svelte/redirect/index.d.ts

@@ -1,13 +1,7 @@
+import { type GotoOptions } from '$app/navigation';
 export type RedirectStatus = 300 | 301 | 302 | 303 | 304 | 305 | 306 | 307 | 308;
 export interface IRedirectSettings {
-    clientRedirectSettings?: {
-        replaceState?: boolean | undefined;
-        noScroll?: boolean | undefined;
-        keepFocus?: boolean | undefined;
-        invalidateAll?: boolean | undefined;
-        invalidate?: (string | URL | ((url: URL) => boolean))[] | undefined;
-        state?: App.PageState | undefined;
-    };
+    clientRedirectSettings?: GotoOptions;
     serverRedirectSettings?: {
         status?: RedirectStatus;
     };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@azure-net/kit",
-  "version": "6.0.0-next.7",
+  "version": "6.0.0-next.9",
   "license": "MIT",
   "author": "Pixel1917",
   "description": "Universal toolkit and library collection, developed as part of the Azure-net ecosystem",
@@ -71,16 +71,16 @@
   },
   "peerDependencies": {
     "@sveltejs/kit": ">=3.0.0",
-    "svelte": ">=5.55.4"
+    "svelte": ">=5.57.1"
   },
   "devDependencies": {
     "@eslint/compat": "^2.0.5",
     "@eslint/js": "^10.0.1",
     "@playwright/test": "^1.59.1",
-    "@sveltejs/adapter-auto": "^7.0.1",
+    "@sveltejs/adapter-auto": "^8.0.0",
     "@sveltejs/kit": "^3.0.0",
     "@sveltejs/load-config": "^0.2.2",
-    "@sveltejs/package": "^2.5.7",
+    "@sveltejs/package": "^3.0.1",
     "@sveltejs/vite-plugin-svelte": "^7.0.0",
     "@testing-library/jest-dom": "^6.9.1",
     "@testing-library/svelte": "^5.3.1",
@@ -98,7 +98,7 @@
     "svelte-check": "^4.7.6",
     "typescript": "^6.0.2",
     "typescript-eslint": "^8.58.2",
-    "vite": "^8.0.8",
+    "vite": "^8.0.12",
     "vitest": "^4.1.4"
   },
   "keywords": [