@azure-net/kit 5.5.0 → 6.0.0-next.1

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) => {
@@ -91,28 +67,38 @@ export const createAsyncHelpers = () => {
         const beforeSendResult = await beforeSendResolver(args);
         if (beforeSendResult)
             return beforeSendResult;
-        const req = async () => {
+        const executeAction = async () => {
             const response = await Promise.resolve(action());
-            const result = { response, success: true };
-            await args?.onSuccess?.(result);
-            return result;
+            return { response, success: true };
         };
-        try {
-            return await req();
-        }
-        catch (err) {
-            const { error, retryResult } = await prepareErrors(normalizeError(err), async () => await req());
+        const handleFailure = async (err, retry) => {
+            const { error, retryResult } = await prepareErrors(normalizeError(err), retry);
             if (retryResult) {
-                return retryResult;
+                return completeSuccess(retryResult);
             }
             const result = { error, response: args?.fallbackResponse, success: false };
             try {
                 await args?.onError?.(result);
             }
-            catch (err) {
-                throw await errorParser(new AsyncHelperError('onError caught exception', { cause: normalizeError(err) }));
+            catch (onErrorException) {
+                throw await resolveAzureNetKitError(new AsyncHelperError('onError caught exception', { cause: normalizeError(onErrorException) }));
             }
             return result;
+        };
+        const completeSuccess = async (result) => {
+            try {
+                await args?.onSuccess?.(result);
+                return result;
+            }
+            catch (err) {
+                return handleFailure(err);
+            }
+        };
+        try {
+            return completeSuccess(await executeAction());
+        }
+        catch (err) {
+            return handleFailure(err, executeAction);
         }
     };
     const createAsyncResource = async (action, args) => {
@@ -124,8 +110,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

@@ -76,7 +76,7 @@ class SchemaBuilderImpl {
                 const _preparedData = prepare(data);
                 let _errors = {};
                 let _isValid = true;
-                if (typeof _preparedData !== 'object') {
+                if (_preparedData === null || typeof _preparedData !== 'object') {
                     throw new AzureNetKitInternalError('[Schema] Data in "from" method can be only valid object or formData.');
                 }
                 const validated = (params) => {
@@ -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/http-service/HttpServiceInstance.js

@@ -162,10 +162,14 @@ const parseBodyByFormat = async (response, format) => {
             return (await response.arrayBuffer());
         case 'body':
             return response.body;
-        case 'json':
-            return (await response.json());
-        default:
-            return (await response.json());
+        case 'json': {
+            const text = await response.text();
+            return (text.trim() ? JSON.parse(text) : undefined);
+        }
+        default: {
+            const text = await response.text();
+            return (text.trim() ? JSON.parse(text) : undefined);
+        }
     }
 };
 const withTimeout = (signal, timeout) => {

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';

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

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

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

@@ -13,7 +13,7 @@ type ProviderFactory<T extends ServiceMap, D extends Record<string, ProviderWith
 }) => T;
 export interface ProviderSettings<T extends ServiceMap, D extends Record<string, ProviderWithType<ServiceMap>>> {
     dependsOn?: D;
-    boot?: (services: ResolvedServices<T>) => void | Promise<void>;
+    boot?: (services: ResolvedServices<T>) => undefined;
     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>;

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

@@ -14,17 +14,17 @@ const getProviderCache = (providerName) => {
     }
     else {
         const context = RequestContext.current();
-        if (!context.data.providers) {
-            context.data.providers = new Map();
+        if (!context.data.azureNetKitBoundaryProviders) {
+            context.data.azureNetKitBoundaryProviders = new Map();
         }
-        const providers = context.data.providers;
+        const providers = context.data.azureNetKitBoundaryProviders;
         if (!providers.has(providerName)) {
             providers.set(providerName, new Map());
         }
-        if (!context.data.providersToCleanup) {
-            context.data.providersToCleanup = new Set();
+        if (!context.data.azureNetKitBoundaryProvidersToCleanup) {
+            context.data.azureNetKitBoundaryProvidersToCleanup = new Set();
         }
-        context.data.providersToCleanup.add(providerName);
+        context.data.azureNetKitBoundaryProvidersToCleanup.add(providerName);
         return providers.get(providerName);
     }
 };
@@ -105,12 +105,18 @@ export const createBoundaryProvider = (name, settings) => {
             return factories;
         };
         const providerProxy = new Proxy({}, {
-            get(_, key) {
+            get(target, key, receiver) {
+                if (typeof key === 'symbol')
+                    return Reflect.get(target, key, receiver);
                 if (cache.has(key)) {
                     return cache.get(key);
                 }
                 const factories = getFactories();
-                if (!(key in factories)) {
+                if (!Object.hasOwn(factories, key)) {
+                    if (key === 'then' || key === 'toJSON')
+                        return undefined;
+                    if (Reflect.has(target, key))
+                        return Reflect.get(target, key, receiver);
                     throw new AzureNetKitInternalError(`[BoundaryProvider] Service '${key}' not found in provider '${name}'`);
                 }
                 const factory = factories[key];
@@ -124,29 +130,44 @@ export const createBoundaryProvider = (name, settings) => {
                 cache.set(key, instance);
                 return instance;
             },
-            has(_, key) {
+            has(target, key) {
+                if (typeof key === 'symbol')
+                    return Reflect.has(target, key);
                 if (cache.has(key))
                     return true;
                 const factories = getFactories();
-                return key in factories;
+                return Object.hasOwn(factories, key) || Reflect.has(target, key);
             },
             ownKeys() {
                 const factories = getFactories();
                 const cachedKeys = Array.from(cache.keys());
                 const factoryKeys = Object.keys(factories);
                 return [...new Set([...cachedKeys, ...factoryKeys])];
+            },
+            getOwnPropertyDescriptor(_, key) {
+                if (typeof key === 'symbol')
+                    return undefined;
+                const factories = getFactories();
+                if (!cache.has(key) && !Object.hasOwn(factories, key))
+                    return undefined;
+                return {
+                    configurable: true,
+                    enumerable: true,
+                    get: () => providerProxy[key]
+                };
             }
         });
         if (BROWSER) {
             providerProxyCache.set(name, providerProxy);
         }
         if (boot && !getBootFlag(name)) {
-            setBootFlag(name, true);
             getFactories();
             const bootResult = boot(providerProxy);
-            if (bootResult instanceof Promise) {
-                bootResult.catch((err) => console.error(`Error in boot for provider '${name}':`, err));
+            if (bootResult && typeof bootResult.then === 'function') {
+                void Promise.resolve(bootResult).catch(() => undefined);
+                throw new AzureNetKitInternalError(`[BoundaryProvider] Boot for provider '${name}' must be synchronous.`);
             }
+            setBootFlag(name, true);
         }
         return providerProxy;
     };
@@ -179,7 +200,7 @@ export async function cleanupProvider(name) {
     }
     else {
         const context = RequestContext.current();
-        const providers = context.data.providers;
+        const providers = context.data.azureNetKitBoundaryProviders;
         if (providers?.has(name)) {
             const cache = providers.get(name);
             providers.delete(name);

package/dist/svelte/active-form/ActiveForm.svelte.d.ts

@@ -1,6 +1,6 @@
 import type { RequestErrors } from '../../delivery/schema/index.js';
 import type { AsyncActionResponse } from '../../delivery/injectable-dependencies/AsyncHelpers.js';
-import type { AsyncSignalSvelte } from '../async-signal/AsyncSignal.svelte.js';
+import { type AsyncSignalSvelte } from '../async-signal/AsyncSignal.svelte.js';
 type MaybePromise<T> = T | Promise<T>;
 type PathRequiredShape<T, P extends string> = P extends `${infer Head}.${infer Tail}` ? Head extends keyof T ? {
     [K in Head]-?: PathRequiredShape<NonNullable<T[K]>, Tail>;

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

@@ -1,4 +1,5 @@
-import { ObjectUtil } from '../../external/tools/index.js';
+import { BROWSER, ObjectUtil } from '../../external/tools/index.js';
+import { isAsyncSignalScheduledForClient } from '../async-signal/AsyncSignal.svelte.js';
 import { cloneStateValue } from '../shared/cloneStateValue.js';
 const NO_INITIAL_VALUES_ERROR = Symbol('no-initial-values-error');
 const isPromiseLike = (value) => {
@@ -29,7 +30,7 @@ export const createActiveForm = (onSubmit, config) => {
     $effect(() => {
         for (const binding of signalBindings) {
             const status = binding.signal.status;
-            const data = binding.signal.data;
+            const data = binding.signal.response;
             const shouldUpdate = binding.active && status === 'success' && (binding.lastStatus !== 'success' || !Object.is(binding.lastData, data));
             binding.lastStatus = status;
             binding.lastData = data;
@@ -40,6 +41,7 @@ export const createActiveForm = (onSubmit, config) => {
     const loadInitialValues = async () => {
         const runId = ++initialLoadRunId;
         const source = config?.initialValues;
+        let waitingForClientSignal = false;
         initialValuesError = NO_INITIAL_VALUES_ERROR;
         if (!source) {
             bindingsBySignal?.clear();
@@ -67,7 +69,7 @@ export const createActiveForm = (onSubmit, config) => {
                             map: map,
                             active: false,
                             loadRunId: runId,
-                            lastData: signal.data,
+                            lastData: signal.response,
                             lastStatus: signal.status
                         };
                         bindings.set(untypedSignal, binding);
@@ -79,9 +81,13 @@ export const createActiveForm = (onSubmit, config) => {
                     }
                     signalBindings = [...bindings.values()];
                 }
+                if (!BROWSER && isAsyncSignalScheduledForClient(signal)) {
+                    waitingForClientSignal = true;
+                    return undefined;
+                }
                 if (signal.status === 'idle' || signal.status === 'pending')
                     await signal.ready;
-                const value = signal.data;
+                const value = signal.response;
                 if (binding && runId === initialLoadRunId && binding.loadRunId === runId) {
                     binding.active = true;
                     binding.lastData = value;
@@ -101,6 +107,10 @@ export const createActiveForm = (onSubmit, config) => {
             }
             if (runId !== initialLoadRunId)
                 return;
+            if (waitingForClientSignal) {
+                status = 'waitingForInitialValues';
+                return;
+            }
             if (bindingsBySignal) {
                 for (const [signal, binding] of bindingsBySignal) {
                     if (binding.loadRunId !== runId)

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

@@ -13,7 +13,7 @@ export interface AsyncSignalOptions<TData, TError = Error> {
     key?: string;
 }
 export interface AsyncSignalSvelte<TData, TError = Error> {
-    data?: TData;
+    response?: TData;
     error?: TError;
     status: AsyncStatus;
     pending: boolean;
@@ -32,6 +32,7 @@ export interface AsyncSignalBatchFactory {
 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 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>;

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

@@ -1,6 +1,20 @@
 import { 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');
+export const isAsyncSignalScheduledForClient = (signal) => {
+    return signal[ASYNC_SIGNAL_SCHEDULED_FOR_CLIENT]?.() ?? false;
+};
+const createDeferred = () => {
+    let resolve;
+    const promise = new Promise((promiseResolve) => {
+        resolve = promiseResolve;
+    });
+    return { promise, resolve };
+};
+const createResolvedPromise = (value) => {
+    return new Promise((resolve) => resolve(value));
+};
 const createAsyncSignalManager = () => {
     const instances = BROWSER ? new Map() : undefined;
     const generateUid = () => {
@@ -49,17 +63,36 @@ const asyncSignalManager = createAsyncSignalManager();
 export const createAsyncSignal = (handler, options = {}) => {
     const { server = false, immediate = true, initialData = undefined, key } = options;
     const resolvedInitialData = typeof initialData === 'function' ? initialData() : initialData;
+    let scheduledForClient = immediate && !BROWSER && !server;
     let data = $state(resolvedInitialData);
     let error = $state();
-    let status = $state('idle');
+    let status = $state(scheduledForClient ? 'pending' : 'idle');
     const pending = $derived(status === 'pending');
     let abortController = null;
     let currentPromise = null;
+    let readyPromise = createResolvedPromise(resolvedInitialData);
+    let resolveReady = null;
     let currentRunId = 0;
     let started = false;
     let batchLocked = false;
     let batchGate = null;
     let batchSkipRequested = false;
+    const startReadyCycle = () => {
+        if (resolveReady)
+            return;
+        const deferred = createDeferred();
+        readyPromise = deferred.promise;
+        resolveReady = deferred.resolve;
+    };
+    const settleReadyCycle = () => {
+        const resolve = resolveReady;
+        if (!resolve) {
+            readyPromise = createResolvedPromise(data);
+            return;
+        }
+        resolveReady = null;
+        resolve(data);
+    };
     const run = async (runId, source) => {
         const initial = !started;
         started = true;
@@ -112,10 +145,13 @@ export const createAsyncSignal = (handler, options = {}) => {
                 currentPromise = null;
                 if (abortController === localController)
                     abortController = null;
+                settleReadyCycle();
             }
         }
     };
     const start = (source) => {
+        scheduledForClient = false;
+        startReadyCycle();
         const runId = ++currentRunId;
         const localPromise = run(runId, source);
         currentPromise = localPromise;
@@ -123,7 +159,7 @@ export const createAsyncSignal = (handler, options = {}) => {
     };
     const startWhenUnlocked = (source) => {
         if (batchLocked)
-            return batchGate ?? Promise.resolve(data);
+            return batchGate ?? readyPromise;
         return start(source);
     };
     const execute = async () => {
@@ -165,7 +201,7 @@ export const createAsyncSignal = (handler, options = {}) => {
         }
     }
     const asyncSignal = {
-        get data() {
+        get response() {
             return data;
         },
         get error() {
@@ -179,14 +215,13 @@ export const createAsyncSignal = (handler, options = {}) => {
         },
         get ready() {
             if (batchLocked)
-                return (batchGate ?? Promise.resolve(data));
-            if (currentPromise)
-                return currentPromise;
-            return start('auto');
+                return (batchGate ?? readyPromise);
+            return readyPromise;
         },
         execute,
         refresh,
         reset: () => {
+            scheduledForClient = false;
             if (batchLocked)
                 batchSkipRequested = true;
             currentRunId += 1;
@@ -196,8 +231,10 @@ export const createAsyncSignal = (handler, options = {}) => {
             data = undefined;
             error = undefined;
             status = 'idle';
+            settleReadyCycle();
         },
         abort: () => {
+            scheduledForClient = false;
             if (batchLocked)
                 batchSkipRequested = true;
             currentRunId += 1;
@@ -206,8 +243,12 @@ export const createAsyncSignal = (handler, options = {}) => {
             currentPromise = null;
             error = undefined;
             status = 'idle';
+            settleReadyCycle();
         }
     };
+    Object.defineProperty(asyncSignal, ASYNC_SIGNAL_SCHEDULED_FOR_CLIENT, {
+        value: () => scheduledForClient
+    });
     Object.defineProperty(asyncSignal, ASYNC_SIGNAL_BATCH_INTERNAL, {
         value: {
             lock: (gate) => {
@@ -228,13 +269,6 @@ export const createAsyncSignal = (handler, options = {}) => {
     });
     return asyncSignal;
 };
-const createDeferred = () => {
-    let resolve;
-    const promise = new Promise((promiseResolve) => {
-        resolve = promiseResolve;
-    });
-    return { promise, resolve };
-};
 export const createAsyncSignalBatch = (factory, options = {}) => {
     const internals = new Map();
     const createSignal = (handler, signalOptions = {}) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@azure-net/kit",
-  "version": "5.5.0",
+  "version": "6.0.0-next.1",
   "license": "MIT",
   "author": "Pixel1917",
   "description": "Universal toolkit and library collection, developed as part of the Azure-net ecosystem",

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

@@ -1,7 +0,0 @@
-import { AppError, type IAppError } from '../../shared/app-error/AppError.js';
-import { AppEvents } from '../../shared/event-bus/EventBus.js';
-import type { AsyncHelperRetry } from './AsyncHelpers.js';
-export type ErrorHandlerContext = {
-    AppEvents: typeof AppEvents;
-};
-export declare const createErrorHandler: <CustomData extends object>(handle?: <T = unknown>(error: AppError<T>, asyncHelperRetry: AsyncHelperRetry, context: ErrorHandlerContext) => Promise<IAppError<T> & CustomData>) => <T = unknown>(error: Error, asyncHelperRetry?: AsyncHelperRetry) => Promise<IAppError<T> & CustomData>;

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

@@ -1,15 +0,0 @@
-import { AppError } from '../../shared/app-error/AppError.js';
-import { AppEvents } from '../../shared/event-bus/EventBus.js';
-export const createErrorHandler = (handle) => {
-    return async (error, asyncHelperRetry) => {
-        const appError = new AppError(error);
-        if (handle) {
-            const handled = await handle(appError, asyncHelperRetry ?? { can: false }, { AppEvents });
-            if (handled?.appErrorConvert) {
-                return handled;
-            }
-            throw new Error('Method "handle" must return result of "toPlainObject" method in AppError');
-        }
-        return appError.toPlainObject();
-    };
-};