@azure-net/kit 5.4.0 → 6.0.0-next

package/dist/delivery/index.d.ts

@@ -1,3 +1,3 @@
-export { createAsyncHelpers, createErrorHandler, type AsyncHelperRetry, type AsyncResourceSettings, type AsyncActionResponse } from './injectable-dependencies/index.js';
+export { createAsyncHelpers, type AsyncHelperRetry, type AsyncResourceSettings, type AsyncActionResponse } from './injectable-dependencies/index.js';
 export { createSchemaFactory, schema, type Schema, type RequestErrors, type ISchemaError, type ValidationResult, type ValidationRuleResult, type ValidationParams, type ValidationMessage, type ValidationErrorsMap } from './schema/index.js';
 export { createRules, validationMessagesRu, validationMessagesI18n, validationMessagesEn, type ValidationRuleParams, type BaseValidationMessages } from './schema/rules/index.js';

package/dist/delivery/index.js

@@ -1,3 +1,3 @@
-export { createAsyncHelpers, createErrorHandler } from './injectable-dependencies/index.js';
+export { createAsyncHelpers } from './injectable-dependencies/index.js';
 export { createSchemaFactory, schema } from './schema/index.js';
 export { createRules, validationMessagesRu, validationMessagesI18n, validationMessagesEn } from './schema/rules/index.js';

package/dist/delivery/injectable-dependencies/AsyncHelpers.d.ts

@@ -1,16 +1,11 @@
-import { createErrorHandler } from './ErrorHandler.js';
 import { type AppError, type IAppError } from '../../shared/app-error/AppError.js';
+export type { AsyncHelperRetry } from '../../shared/app-error/ErrorRuntime.js';
 export interface AsyncActionResponse<T, D = never, ErrorResult = Record<never, never>> {
     success: boolean;
     response: T;
     error?: IAppError<D> & ErrorResult;
 }
-export interface AsyncHelperRetry {
-    can: boolean;
-    call?: () => Promise<Error | void>;
-}
 type Action<Res> = () => Promise<Res>;
-type ErrorParser<ErrorResult extends object> = ReturnType<typeof createErrorHandler<ErrorResult>>;
 export interface AsyncActionSettings<Res = never, Req = never, ErrorResult = AppError<Error>> {
     beforeSend?: (actions: {
         next: () => void;
@@ -23,12 +18,7 @@ export interface AsyncActionSettings<Res = never, Req = never, ErrorResult = App
 export interface AsyncResourceSettings<Res = never, Req = never, ErrorResult = AppError<Error>> extends AsyncActionSettings<Res, Req, ErrorResult> {
     reject?: boolean;
 }
-export declare class AsyncHelperError extends Error {
-}
 export declare const createAsyncHelpers: <ErrorResult extends object>() => {
     createAsyncAction: <Res = never, Req = never>(action: Action<Res>, args?: AsyncActionSettings<Res, Req, ErrorResult>) => Promise<AsyncActionResponse<Res, Req, ErrorResult>>;
     createAsyncResource: <Res = never, Req_1 = never>(action: Action<Res>, args?: AsyncResourceSettings<Res, Req_1, ErrorResult>) => Promise<Res>;
-    errorParser: <T = unknown>(error: Error, asyncHelperRetry?: AsyncHelperRetry) => Promise<IAppError<T> & ErrorResult>;
-    useHandler: (parser: ErrorParser<ErrorResult>) => void;
 };
-export {};

package/dist/delivery/injectable-dependencies/AsyncHelpers.js

@@ -1,33 +1,6 @@
-import { createErrorHandler } from './ErrorHandler.js';
-import {} from '../../shared/app-error/AppError.js';
-import { BROWSER } from '../../external/tools/index.js';
-import { RequestContext } from '../../external/edges/ServerContext.js';
-export class AsyncHelperError extends Error {
-}
+import { AsyncHelperError } from '../../shared/app-error/AppError.js';
+import { resolveAzureNetKitError } from '../../shared/app-error/ErrorRuntime.js';
 export const createAsyncHelpers = () => {
-    const defaultErrorParser = createErrorHandler();
-    const handlerContextKey = Symbol('azureNetAsyncHelperErrorParser');
-    let clientErrorParser;
-    const getErrorParser = () => {
-        if (BROWSER)
-            return clientErrorParser ?? defaultErrorParser;
-        try {
-            const data = RequestContext.current().data;
-            return data[handlerContextKey] ?? defaultErrorParser;
-        }
-        catch {
-            return defaultErrorParser;
-        }
-    };
-    const errorParser = async (error, asyncHelperRetry) => await getErrorParser()(error, asyncHelperRetry);
-    const useHandler = (parser) => {
-        if (BROWSER) {
-            clientErrorParser = parser;
-            return;
-        }
-        const data = RequestContext.current().data;
-        data[handlerContextKey] = parser;
-    };
     const normalizeError = (err) => (err instanceof Error ? err : new Error(String(err)));
     const prepareErrors = async (error, retry) => {
         let retryResult = undefined;
@@ -41,7 +14,10 @@ export const createAsyncHelpers = () => {
                     .catch((err) => normalizeError(err));
             }
         };
-        const parsedError = await errorParser(normalizeError(error), { can: !!retry, call: retry ? () => retryFunc() : undefined });
+        const parsedError = await resolveAzureNetKitError(normalizeError(error), {
+            can: !!retry,
+            call: retry ? () => retryFunc() : undefined
+        });
         return { error: parsedError, retryResult };
     };
     const beforeSendResolver = async (settings) => {
@@ -110,7 +86,7 @@ export const createAsyncHelpers = () => {
                 await args?.onError?.(result);
             }
             catch (err) {
-                throw await errorParser(new AsyncHelperError('onError caught exception', { cause: normalizeError(err) }));
+                throw await resolveAzureNetKitError(new AsyncHelperError('onError caught exception', { cause: normalizeError(err) }));
             }
             return result;
         }
@@ -124,8 +100,6 @@ export const createAsyncHelpers = () => {
     };
     return {
         createAsyncAction,
-        createAsyncResource,
-        errorParser,
-        useHandler
+        createAsyncResource
     };
 };

package/dist/delivery/injectable-dependencies/index.d.ts

@@ -1,2 +1 @@
 export * from './AsyncHelpers.js';
-export * from './ErrorHandler.js';

package/dist/delivery/injectable-dependencies/index.js

@@ -1,2 +1 @@
 export * from './AsyncHelpers.js';
-export * from './ErrorHandler.js';

package/dist/delivery/schema/Schema.d.ts

@@ -47,13 +47,13 @@ interface SchemaBuilder<SchemaData, Rules = unknown, TransformResult = SchemaDat
     create(): Schema<SchemaData, TransformResult, CustomMethods>;
 }
 interface SchemaInstance<TransformResult, SchemaData> {
-    json(params?: TransformationParams<SchemaData>): TransformResult;
-    formData(params?: TransformationParams<SchemaData>): FormData;
+    toJson(params?: TransformationParams<SchemaData>): TransformResult;
+    toFormData(params?: TransformationParams<SchemaData>): FormData;
     validated(): {
         valid: boolean;
         errors: RequestErrors<SchemaData>;
-        json(): TransformResult;
-        formData(): FormData;
+        toJson(): TransformResult;
+        toFormData(): FormData;
     };
 }
 export type Schema<SchemaData, TransformResult, CustomMethods> = CustomMethods & {

package/dist/delivery/schema/Schema.js

@@ -109,18 +109,18 @@ class SchemaBuilderImpl {
                     return {
                         valid: _isValid,
                         errors: _errors,
-                        json: () => json({ validate: false }),
-                        formData: () => formData({ validate: false })
+                        toJson: () => toJson({ validate: false }),
+                        toFormData: () => toFormData({ validate: false })
                     };
                 };
-                const json = (params = {}) => {
+                const toJson = (params = {}) => {
                     const { validate = true, onValidationError } = params;
                     if (validate && !validated({ onValidationError }).valid) {
                         throw new SchemaFail(_errors);
                     }
                     return transform(_preparedData);
                 };
-                const formData = (params = {}) => {
+                const toFormData = (params = {}) => {
                     const { validate = true, onValidationError } = params;
                     if (validate && !validated({ onValidationError }).valid) {
                         throw new SchemaFail(_errors);
@@ -128,8 +128,8 @@ class SchemaBuilderImpl {
                     return FormDataUtil.fromObject(transform(_preparedData));
                 };
                 return {
-                    json,
-                    formData,
+                    toJson,
+                    toFormData,
                     validated
                 };
             }

package/dist/delivery/schema/rules/Rules.js

@@ -10,6 +10,9 @@ export const createRules = (validationMessages) => {
     const checkVal = (val) => {
         return val !== undefined && val !== null;
     };
+    const isNumericInput = (val) => {
+        return typeof val === 'number' || (typeof val === 'string' && val.trim().length > 0);
+    };
     /**
      * Checks a value against a regular expression.
      */
@@ -137,8 +140,10 @@ export const createRules = (validationMessages) => {
         const { message, range } = { ...params, message: { ...validationMessages.number, ...params?.message } };
         return ({ val }) => {
             if (checkVal(val)) {
+                if (!isNumericInput(val))
+                    return message.base();
                 const numberVal = Number(val);
-                if (!Number.isInteger(numberVal) || Number.isNaN(numberVal)) {
+                if (!Number.isInteger(numberVal)) {
                     return message.base();
                 }
                 switch (true) {
@@ -163,12 +168,15 @@ export const createRules = (validationMessages) => {
         const { message, maxDigitsAfterDot, range } = { ...params, message: { ...validationMessages.finite, ...params?.message } };
         return ({ val }) => {
             if (checkVal(val)) {
+                if (!isNumericInput(val))
+                    return message.base();
+                const normalizedValue = typeof val === 'string' ? val.trim() : String(val);
                 const numVal = Number(val);
-                if (!Number.isFinite(numVal) || String(val)[0] === '.') {
+                if (!Number.isFinite(numVal) || normalizedValue.startsWith('.')) {
                     return message.base();
                 }
                 if (typeof maxDigitsAfterDot === 'number') {
-                    const digitsAfterDot = val.toString().split('.')[1]?.length ?? 0;
+                    const digitsAfterDot = normalizedValue.split('.')[1]?.length ?? 0;
                     if (digitsAfterDot > maxDigitsAfterDot) {
                         return message.maxDigitsAfterDot(maxDigitsAfterDot);
                     }
@@ -213,9 +221,9 @@ export const createRules = (validationMessages) => {
             if (checkVal(val)) {
                 if (!Array.isArray(val))
                     return message.base();
-                if (length.min && val.length < length.min)
+                if (length.min !== undefined && val.length < length.min)
                     return message.min(length.min);
-                if (length.max && val.length > length.max)
+                if (length.max !== undefined && val.length > length.max)
                     return message.max(length.max);
                 if (schema) {
                     const nestedErrors = [];
@@ -359,7 +367,7 @@ export const createRules = (validationMessages) => {
         const normalizedBlockedDomains = blockedDomains?.map(normalizeDomain).filter(Boolean);
         const emailRegExp = 
         // eslint-disable-next-line no-control-regex
-        /^(?:[A-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[A-z0-9!#$%&'*+/=?^_`{|}~-]+)*|"(?:[\x01-\x08\x0B\x0C\x0E-\x1F\x21\x23-\x5B\x5D-\x7F]|[\x01-\x09\x0B\x0C\x0E-\x7F])*")@(?:(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9]{2,}(?:[a-z0-9-]*[a-z0-9])?|\[(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?|[a-z0-9-]*[a-z0-9]:(?:[\x01-\x08\x0B\x0C\x0E-\x1F\x21-\x5A\x53-\x7F]|\\[\x01-\x09\x0B\x0C\x0E-\x7F])+)])$/i;
+        /^(?:[A-Za-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[A-Za-z0-9!#$%&'*+/=?^_`{|}~-]+)*|"(?:[\x01-\x08\x0B\x0C\x0E-\x1F\x21\x23-\x5B\x5D-\x7F]|[\x01-\x09\x0B\x0C\x0E-\x7F])*")@(?:(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9]{2,}(?:[a-z0-9-]*[a-z0-9])?|\[(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?|[a-z0-9-]*[a-z0-9]:(?:[\x01-\x08\x0B\x0C\x0E-\x1F\x21-\x5A\x53-\x7F]|\\[\x01-\x09\x0B\x0C\x0E-\x7F])+)])$/i;
         return ({ val }) => {
             if (!checkVal(val))
                 return undefined;

package/dist/errors.d.ts

@@ -1,4 +1,3 @@
-export { AppError, ErrorTypes, AzureNetKitInternalError, type IAppError } from './shared/app-error/AppError.js';
+export { AppError, AsyncHelperError, ErrorTypes, AzureNetKitInternalError, type IAppError } from './shared/app-error/AppError.js';
 export { HttpServiceError } from './infra/http-service/HttpServiceInstance.js';
-export { AsyncHelperError } from './delivery/injectable-dependencies/AsyncHelpers.js';
 export { SchemaFail } from './delivery/schema/Schema.js';

package/dist/errors.js

@@ -1,4 +1,3 @@
-export { AppError, ErrorTypes, AzureNetKitInternalError } from './shared/app-error/AppError.js';
+export { AppError, AsyncHelperError, ErrorTypes, AzureNetKitInternalError } from './shared/app-error/AppError.js';
 export { HttpServiceError } from './infra/http-service/HttpServiceInstance.js';
-export { AsyncHelperError } from './delivery/injectable-dependencies/AsyncHelpers.js';
 export { SchemaFail } from './delivery/schema/Schema.js';

package/dist/infra/response/BaseResponse.d.ts

@@ -19,7 +19,7 @@ export declare class ResponseBuilder<TData = unknown, TMeta = object, TWrapper =
     mapCollectionUsing<TResource>(ResourceClass: new (data: ArrayElement<TData>) => {
         toPlainObject(): TResource;
     }): Omit<this, keyof ResponseBuilder<unknown, unknown, unknown>> & ResponseBuilder<TResource[], TMeta, TWrapper>;
-    extract<TPath extends DeepKeys<TData>>(path: TPath): Omit<this, keyof ResponseBuilder<unknown, unknown, unknown>> & ResponseBuilder<DeepValue<TData, TPath>, TMeta, TWrapper>;
+    extractKey<TPath extends DeepKeys<TData>>(path: TPath): Omit<this, keyof ResponseBuilder<unknown, unknown, unknown>> & ResponseBuilder<DeepValue<TData, TPath>, TMeta, TWrapper>;
     addMeta<TNewMeta extends Record<string, unknown>>(metaData: TNewMeta | ((current: TMeta & TNewMeta) => TMeta & TNewMeta)): Omit<this, keyof ResponseBuilder<unknown, unknown, unknown>> & ResponseBuilder<TData, TMeta & TNewMeta, TWrapper>;
     getData(): TData;
     get(): {

package/dist/infra/response/BaseResponse.js

@@ -33,7 +33,7 @@ export class ResponseBuilder {
         };
         return newResponse;
     }
-    extract(path) {
+    extractKey(path) {
         const keys = path.split('.');
         let result = this.state.data;
         for (const key of keys) {

package/dist/plugin/AzureNetPlugin.js

@@ -52,7 +52,7 @@ export const handle = edgesHandle(async ({ serialize, edgesEvent, resolve }) =>
 			resolve(event, {
 				...options,
 				transformPageChunk: async (chunk) => {
-					const html = options?.transformPageChunk ? await options.transformPageChunk(chunk) : chunk.html;
+					const html = (options?.transformPageChunk ? await options.transformPageChunk(chunk) : undefined) ?? chunk.html;
 					return serialize(html);
 				}
 			})

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

@@ -1,4 +1,7 @@
 import { type ContextData } from '../../external/edges/ServerContext.js';
+import { AppError, type IAppError } from '../app-error/AppError.js';
+import { type AsyncHelperRetry } from '../app-error/ErrorRuntime.js';
+import { AppEvents } from '../event-bus/EventBus.js';
 import { type IServerMiddleware } from './middleware/ServerMiddleware.js';
 import type { Handle, HandleClientError, HandleFetch, HandleServerError, HandleValidationError, RequestEvent, Reroute, ServerInit, Transport } from '@sveltejs/kit';
 import { type IClientMiddleware } from './middleware/ClientMiddleware.js';
@@ -11,7 +14,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' | 'useServerFetch' | 'useServerValidationError' | 'useReroute' | 'useTransport', true>>;
+type BuilderFlags = Partial<Record<'use' | 'useClient' | 'useClientInit' | 'useClientError' | 'useServerInit' | 'useServer' | 'useServerError' | 'useServerFetch' | 'useServerValidationError' | 'useAzureNetKitError' | '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;
@@ -63,6 +66,16 @@ export type AppServerValidationErrorContext<TDependencies extends Record<string,
     Container: AppContainer<TDependencies>;
     requestContext: ContextData;
 };
+export interface AppAzureNetKitErrorContext<TDependencies extends Record<string, unknown>> {
+    Container: AppContainer<TDependencies>;
+    AppEvents: typeof AppEvents;
+    error: AppError;
+    retry: AsyncHelperRetry;
+    isClient: boolean;
+    isServer: boolean;
+    requestContext?: ContextData;
+    event?: RequestEvent;
+}
 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>;
@@ -72,6 +85,7 @@ export type AppServerLifecycleCallback<TDependencies extends Record<string, unkn
 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 AppAzureNetKitErrorCallback<TDependencies extends Record<string, unknown>> = (context: AppAzureNetKitErrorContext<TDependencies>) => MaybePromise<IAppError & object>;
 export type AppRerouteCallback = Reroute;
 export type CreateAppBuilder<TDependencies extends Record<string, unknown>, TFlags extends BuilderFlags = object> = {
     readonly __types__?: TDependencies;
@@ -94,6 +108,8 @@ export type CreateAppBuilder<TDependencies extends Record<string, unknown>, TFla
     useServerFetch(callback: AppServerFetchCallback<TDependencies>): CreateAppBuilder<TDependencies, WithFlag<TFlags, 'useServerFetch'>>;
 }> & OnceMethod<TFlags, 'useServerValidationError', {
     useServerValidationError(callback: AppServerValidationErrorCallback<TDependencies>): CreateAppBuilder<TDependencies, WithFlag<TFlags, 'useServerValidationError'>>;
+}> & OnceMethod<TFlags, 'useAzureNetKitError', {
+    useAzureNetKitError(callback: AppAzureNetKitErrorCallback<TDependencies>): CreateAppBuilder<TDependencies, WithFlag<TFlags, 'useAzureNetKitError'>>;
 }> & OnceMethod<TFlags, 'useReroute', {
     useReroute(callback: AppRerouteCallback): CreateAppBuilder<TDependencies, WithFlag<TFlags, 'useReroute'>>;
 }> & OnceMethod<TFlags, 'useTransport', {

package/dist/shared/app/App.js

@@ -1,7 +1,9 @@
 import { BROWSER } from '../../external/tools/index.js';
 import { RequestContext } from '../../external/edges/ServerContext.js';
 import { createBoundaryProvider } from '../boundary-provider/Provider.js';
-import { AzureNetKitInternalError } from '../app-error/AppError.js';
+import { AppError, AzureNetKitInternalError } from '../app-error/AppError.js';
+import { bindAzureNetKitErrorResolver } from '../app-error/ErrorRuntime.js';
+import { AppEvents } from '../event-bus/EventBus.js';
 import { executeServerMiddlewares } from './middleware/ServerMiddleware.js';
 import { beforeNavigate } from '$app/navigation';
 import { executeClientMiddlewares } from './middleware/ClientMiddleware.js';
@@ -87,6 +89,10 @@ const createBuilder = (dependencies, callbacks) => {
             setCallback(callbacks, 'useServerValidationError', callback);
             return builder;
         },
+        useAzureNetKitError(callback) {
+            setCallback(callbacks, 'useAzureNetKitError', callback);
+            return builder;
+        },
         useReroute(callback) {
             setCallback(callbacks, 'useReroute', callback);
             return builder;
@@ -142,9 +148,28 @@ export const createApp = (callback, name = DEFAULT_APP_NAME) => {
             };
         }
     });
+    const errorResolver = callbacks.useAzureNetKitError
+        ? (error, retry) => {
+            const requestContext = BROWSER ? undefined : getRequestContext();
+            return callbacks.useAzureNetKitError({
+                Container,
+                AppEvents,
+                error,
+                retry,
+                isClient: BROWSER,
+                isServer: !BROWSER,
+                requestContext,
+                event: requestContext?.event
+            });
+        }
+        : undefined;
+    const bindErrorResolver = (requestContext) => {
+        bindAzureNetKitErrorResolver(errorResolver, requestContext);
+    };
     const runClient = (kind) => {
         if (!BROWSER)
             return undefined;
+        bindErrorResolver();
         const flags = getLifecycleFlags(appKey);
         if (flags[kind])
             return undefined;
@@ -172,8 +197,8 @@ export const createApp = (callback, name = DEFAULT_APP_NAME) => {
             if (clientInitialized)
                 return;
             clientInitialized = true;
-            beforeNavigate(async (navigation) => {
-                await executeClientMiddlewares(internalMiddlewares, navigation);
+            beforeNavigate((navigation) => {
+                executeClientMiddlewares(internalMiddlewares, navigation);
             });
         };
         if (clientResult && typeof clientResult.then === 'function') {
@@ -190,19 +215,33 @@ export const createApp = (callback, name = DEFAULT_APP_NAME) => {
     const runServerError = ({ error, event, status, message }) => {
         if (BROWSER)
             return undefined;
-        return callbacks.useServerError?.({
-            Container,
-            requestContext: getServerRequestContext(),
-            error,
-            event,
-            status,
-            message,
-            useLogger
-        });
+        const requestContext = getServerRequestContext();
+        bindErrorResolver(requestContext);
+        try {
+            const result = callbacks.useServerError?.({
+                Container,
+                requestContext,
+                error,
+                event,
+                status,
+                message,
+                useLogger
+            });
+            if (result && typeof result.then === 'function') {
+                return Promise.resolve(result).finally(() => bindAzureNetKitErrorResolver(undefined, requestContext));
+            }
+            bindAzureNetKitErrorResolver(undefined, requestContext);
+            return result;
+        }
+        catch (error) {
+            bindAzureNetKitErrorResolver(undefined, requestContext);
+            throw error;
+        }
     };
     const runClientError = ({ error, event, status, message }) => {
         if (!BROWSER)
             return undefined;
+        bindErrorResolver();
         return callbacks.useClientError?.({
             Container,
             error,
@@ -234,30 +273,36 @@ export const createApp = (callback, name = DEFAULT_APP_NAME) => {
     const reroute = (input) => callbacks.useReroute?.(input);
     const handle = async ({ event, resolve }) => {
         const requestContext = getServerRequestContext();
-        const flags = getLifecycleFlags(appKey, requestContext);
-        if (!flags.server) {
-            flags.server = true;
-            const universalResult = callbacks.use?.({
-                Container,
-                isClient: false,
-                isServer: true,
-                requestContext,
-                event
-            });
-            if (universalResult && typeof universalResult.then === 'function') {
-                await universalResult;
+        bindErrorResolver(requestContext);
+        try {
+            const flags = getLifecycleFlags(appKey, requestContext);
+            if (!flags.server) {
+                flags.server = true;
+                const universalResult = callbacks.use?.({
+                    Container,
+                    isClient: false,
+                    isServer: true,
+                    requestContext,
+                    event
+                });
+                if (universalResult && typeof universalResult.then === 'function') {
+                    await universalResult;
+                }
+                const serverResult = await callbacks.useServer?.({
+                    Container,
+                    requestContext,
+                    event,
+                    resolve,
+                    useMiddlewares: executeServerMiddlewares
+                });
+                if (serverResult)
+                    return serverResult;
             }
-            const serverResult = await callbacks.useServer?.({
-                Container,
-                requestContext,
-                event,
-                resolve,
-                useMiddlewares: executeServerMiddlewares
-            });
-            if (serverResult)
-                return serverResult;
+            return await resolve(event);
+        }
+        finally {
+            bindAzureNetKitErrorResolver(undefined, requestContext);
         }
-        return resolve(event);
     };
     const register = Object.assign(() => runClient('client'), {
         clientInit: () => runClient('clientInit'),

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 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 { createApp, type AppAzureNetKitErrorCallback, type AppAzureNetKitErrorContext, 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/app/middleware/ClientMiddleware.d.ts

@@ -4,7 +4,7 @@ import type { RedirectStatus } from '../../redirect/index.js';
 export type IClientMiddleware = (middlewareData: {
     to: URL;
     from?: URL;
-    next: (location?: string | URL, status?: RedirectStatus) => void;
+    next: (location?: string | URL, status?: RedirectStatus) => undefined;
     ensureRoute: EnsureRoute;
-}) => Promise<void> | void;
-export declare const executeClientMiddlewares: (middlewares: IClientMiddleware[], navigation?: BeforeNavigate) => Promise<void>;
+}) => undefined;
+export declare const executeClientMiddlewares: (middlewares: IClientMiddleware[], navigation?: BeforeNavigate) => void;

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

@@ -2,7 +2,7 @@ import {} from '@sveltejs/kit';
 import { ensureRoute } from './Shared.js';
 import { page } from '$app/state';
 import { goto } from '$app/navigation';
-export const executeClientMiddlewares = async (middlewares, navigation) => {
+export const executeClientMiddlewares = (middlewares, navigation) => {
     const from = navigation?.from?.url ?? undefined;
     const to = navigation?.to?.url ?? page?.url;
     for (const middleware of middlewares) {
@@ -11,18 +11,17 @@ export const executeClientMiddlewares = async (middlewares, navigation) => {
         const next = (location) => {
             shouldContinue = true;
             redirectTo = location;
+            return undefined;
         };
-        const result = middleware({
+        middleware({
             to,
             from,
             next,
             ensureRoute
         });
-        if (result && typeof result.then === 'function')
-            await result;
         if (redirectTo) {
             navigation?.cancel();
-            await goto(redirectTo);
+            void goto(redirectTo);
             return;
         }
         if (!shouldContinue) {

package/dist/shared/app-error/AppError.d.ts

@@ -1,5 +1,7 @@
 import { HttpServiceError } from '../../infra/http-service/HttpServiceInstance.js';
 import { type RequestErrors } from '../../delivery/schema/Schema.js';
+export declare class AsyncHelperError extends Error {
+}
 export declare enum ErrorTypes {
     Http = "Http",
     Schema = "Schema",

package/dist/shared/app-error/AppError.js

@@ -1,6 +1,7 @@
 import { HttpErrorTypes, HttpServiceError } from '../../infra/http-service/HttpServiceInstance.js';
 import { SchemaFail } from '../../delivery/schema/Schema.js';
-import { AsyncHelperError } from '../../delivery/injectable-dependencies/AsyncHelpers.js';
+export class AsyncHelperError extends Error {
+}
 export var ErrorTypes;
 (function (ErrorTypes) {
     ErrorTypes["Http"] = "Http";

package/dist/shared/app-error/ErrorRuntime.d.ts

@@ -0,0 +1,11 @@
+import { type ContextData } from '../../external/edges/ServerContext.js';
+import { AppError, type IAppError } from './AppError.js';
+type MaybePromise<T> = T | Promise<T>;
+export interface AsyncHelperRetry {
+    can: boolean;
+    call?: () => Promise<Error | void>;
+}
+export type AzureNetKitErrorResolver = (error: AppError, retry: AsyncHelperRetry) => MaybePromise<IAppError & object>;
+export declare const bindAzureNetKitErrorResolver: (resolver?: AzureNetKitErrorResolver, requestContext?: ContextData) => void;
+export declare const resolveAzureNetKitError: <Validation = unknown, CustomData extends object = Record<never, never>>(error: unknown, retry?: AsyncHelperRetry) => Promise<IAppError<Validation> & CustomData>;
+export {};

package/dist/shared/app-error/ErrorRuntime.js

@@ -0,0 +1,57 @@
+import { BROWSER } from '../../external/tools/index.js';
+import { RequestContext } from '../../external/edges/ServerContext.js';
+import { AppError, AzureNetKitInternalError } from './AppError.js';
+const SERVER_BINDING_KEY = Symbol('azureNetKitErrorResolver');
+let clientBinding;
+const createBinding = (resolver) => ({ resolver });
+const getServerData = (requestContext) => {
+    if (requestContext)
+        return requestContext.data;
+    try {
+        return RequestContext.current().data;
+    }
+    catch {
+        return undefined;
+    }
+};
+export const bindAzureNetKitErrorResolver = (resolver, requestContext) => {
+    if (BROWSER) {
+        clientBinding = resolver ? createBinding(resolver) : undefined;
+        return;
+    }
+    const data = getServerData(requestContext);
+    if (!data)
+        return;
+    if (resolver) {
+        data[SERVER_BINDING_KEY] = createBinding(resolver);
+    }
+    else {
+        delete data[SERVER_BINDING_KEY];
+    }
+};
+const getBinding = () => {
+    if (BROWSER)
+        return clientBinding;
+    return getServerData()?.[SERVER_BINDING_KEY];
+};
+const normalizeError = (error) => (error instanceof Error ? error : new Error(String(error)));
+export const resolveAzureNetKitError = async (error, retry = { can: false }) => {
+    const normalizedError = normalizeError(error);
+    const appError = normalizedError instanceof AppError ? normalizedError : new AppError(normalizedError);
+    const binding = getBinding();
+    if (!binding || binding.activeErrors?.has(normalizedError)) {
+        return appError.toPlainObject();
+    }
+    const activeErrors = (binding.activeErrors ??= new WeakSet());
+    activeErrors.add(normalizedError);
+    try {
+        const result = await binding.resolver(appError, retry);
+        if (!result?.appErrorConvert) {
+            throw new AzureNetKitInternalError("[createApp] 'useAzureNetKitError' must return the result of AppError.toPlainObject().");
+        }
+        return result;
+    }
+    finally {
+        activeErrors.delete(normalizedError);
+    }
+};

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

@@ -1 +1,2 @@
 export * from './AppError.js';
+export * from './ErrorRuntime.js';