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

package/dist/infra/http-service/HttpServiceInstance.js

@@ -1,5 +1,5 @@
 import { BROWSER } from '../../external/tools/index.js';
-import { RequestContext } from '../../external/edges/ServerContext.js';
+import { RequestContext } from '../../shared/request-context/Internal.js';
 export var HttpInstanceFetchMethods;
 (function (HttpInstanceFetchMethods) {
     HttpInstanceFetchMethods["GET"] = "GET";
@@ -344,15 +344,23 @@ const makeMethod = (method, defaults) => {
         }
     };
 };
-export const createHttpServiceInstance = (config = {}) => {
-    const defaults = { ...config };
-    return {
-        get: makeMethod(HttpInstanceFetchMethods.GET, defaults),
-        post: makeMethod(HttpInstanceFetchMethods.POST, defaults),
-        put: makeMethod(HttpInstanceFetchMethods.PUT, defaults),
-        delete: makeMethod(HttpInstanceFetchMethods.DELETE, defaults),
-        patch: makeMethod(HttpInstanceFetchMethods.PATCH, defaults),
-        head: makeMethod(HttpInstanceFetchMethods.HEAD, defaults),
-        options: makeMethod(HttpInstanceFetchMethods.OPTIONS, defaults)
-    };
-};
+export class HttpServiceInstance {
+    defaults;
+    get;
+    post;
+    put;
+    delete;
+    patch;
+    head;
+    options;
+    constructor(config = {}) {
+        this.defaults = { ...config };
+        this.get = makeMethod(HttpInstanceFetchMethods.GET, this.defaults);
+        this.post = makeMethod(HttpInstanceFetchMethods.POST, this.defaults);
+        this.put = makeMethod(HttpInstanceFetchMethods.PUT, this.defaults);
+        this.delete = makeMethod(HttpInstanceFetchMethods.DELETE, this.defaults);
+        this.patch = makeMethod(HttpInstanceFetchMethods.PATCH, this.defaults);
+        this.head = makeMethod(HttpInstanceFetchMethods.HEAD, this.defaults);
+        this.options = makeMethod(HttpInstanceFetchMethods.OPTIONS, this.defaults);
+    }
+}

package/dist/infra/index.d.ts

@@ -1,5 +1,5 @@
 export { BaseHttpDatasource, type CreateRequestCallbackType } from './datasource/index.js';
 export { DTOMapper, type IDTOMapper } from './resource/index.js';
-export { HttpStatusCode, createHttpServiceInstance, HttpInstanceFetchMethods, HttpErrorTypes, HttpServiceResponse, HttpServiceError, type IHttpServiceError, type IHttpServiceResponse, type IHttpServiceInstance, type IHttpInstanceOptions, type HttpInstanceNormalizedRequest, type HttpInstanceOnRequest, type HttpInstanceOnError, type HttpInstanceDoFetch, type HttpInstanceRequestMethod } from './http-service/index.js';
+export { HttpStatusCode, HttpServiceInstance, HttpInstanceFetchMethods, HttpErrorTypes, HttpServiceResponse, HttpServiceError, type IHttpServiceError, type IHttpServiceResponse, type IHttpServiceInstance, type IHttpInstanceOptions, type IHttpInstanceNormalizedRequest, type IHttpInstanceOnRequest, type IHttpInstanceOnError, type IHttpInstanceDoFetch, type IHttpInstanceRequestMethod } from './http-service/index.js';
 export { ResponseBuilder } from './response/index.js';
-export { createQueryInstance, type IQueryBuilderInstance, type ArrayFormat, type ObjectFormat, type IQueryBuilderSettings } from './query/QueryBuilder.js';
+export { QueryBuilder, type IQueryBuilderInstance, type ArrayFormat, type ObjectFormat, type IQueryBuilderSettings } from './query/QueryBuilder.js';

package/dist/infra/index.js

@@ -1,5 +1,5 @@
 export { BaseHttpDatasource } from './datasource/index.js';
 export { DTOMapper } from './resource/index.js';
-export { HttpStatusCode, createHttpServiceInstance, HttpInstanceFetchMethods, HttpErrorTypes, HttpServiceResponse, HttpServiceError } from './http-service/index.js';
+export { HttpStatusCode, HttpServiceInstance, HttpInstanceFetchMethods, HttpErrorTypes, HttpServiceResponse, HttpServiceError } from './http-service/index.js';
 export { ResponseBuilder } from './response/index.js';
-export { createQueryInstance } from './query/QueryBuilder.js';
+export { QueryBuilder } from './query/QueryBuilder.js';

package/dist/infra/query/QueryBuilder.d.ts

@@ -10,4 +10,9 @@ export interface IQueryBuilderInstance<TTransformInput extends object = object>
     toString: (query: object, settings?: IQueryBuilderSettings<TTransformInput>) => string;
     toSearchParams: (query: object, settings?: Omit<IQueryBuilderSettings<TTransformInput>, 'delimiter'>) => URLSearchParams;
 }
-export declare const createQueryInstance: <TTransformInput extends object = object>(defaults?: IQueryBuilderSettings<TTransformInput>) => IQueryBuilderInstance<TTransformInput>;
+export declare class QueryBuilder<TTransformInputGlobal extends object = object> implements IQueryBuilderInstance<TTransformInputGlobal> {
+    private readonly defaults;
+    constructor(config?: IQueryBuilderSettings<TTransformInputGlobal>);
+    readonly toSearchParams: <TTransformInput extends TTransformInputGlobal = TTransformInputGlobal>(query: object, settings?: Omit<IQueryBuilderSettings<TTransformInput>, "delimiter">) => URLSearchParams;
+    readonly toString: <TTransformInput extends TTransformInputGlobal = TTransformInputGlobal>(query: object, settings?: IQueryBuilderSettings<TTransformInput>) => string;
+}

package/dist/infra/query/QueryBuilder.js

@@ -75,16 +75,18 @@ const toSearchParamsWithSettings = (query, settings) => {
     }
     return params;
 };
-export const createQueryInstance = (defaults) => {
-    return {
-        toSearchParams: (query, settings) => {
-            const resolved = normalizeSettings(defaults, settings);
-            return toSearchParamsWithSettings(query, resolved);
-        },
-        toString: (query, settings) => {
-            const resolved = normalizeSettings(defaults, settings);
-            const serialized = encodeQuery(Array.from(toSearchParamsWithSettings(query, resolved).entries()));
-            return resolved.delimiter && serialized ? `?${serialized}` : serialized;
-        }
+export class QueryBuilder {
+    defaults;
+    constructor(config) {
+        this.defaults = { ...config };
+    }
+    toSearchParams = (query, settings) => {
+        const resolved = normalizeSettings(this.defaults, settings);
+        return toSearchParamsWithSettings(query, resolved);
     };
-};
+    toString = (query, settings) => {
+        const resolved = normalizeSettings(this.defaults, settings);
+        const serialized = encodeQuery(Array.from(toSearchParamsWithSettings(query, resolved).entries()));
+        return resolved.delimiter && serialized ? `?${serialized}` : serialized;
+    };
+}

package/dist/plugin/AzureNetPlugin.d.ts

@@ -1,5 +1,2 @@
 import type { Plugin } from 'vite';
-export interface AzureNetPluginOptions {
-    silentChromeDevtools?: boolean;
-}
-export declare const AzureNetPlugin: (options?: AzureNetPluginOptions) => Plugin;
+export declare const AzureNetPlugin: () => Plugin;

package/dist/plugin/AzureNetPlugin.js

@@ -1,7 +1,6 @@
+import { fileURLToPath } from 'node:url';
 import path from 'node:path';
 import fs from 'node:fs';
-const VIRTUAL_SERVER_UTILS_ID = 'virtual:azure-net-kit/server-utils';
-const RESOLVED_VIRTUAL_SERVER_UTILS_ID = `\0${VIRTUAL_SERVER_UTILS_ID}`;
 const VIRTUAL_SERVER_HOOKS_ID = 'virtual:azure-net-kit/hooks.server';
 const VIRTUAL_CLIENT_HOOKS_ID = 'virtual:azure-net-kit/hooks.client';
 const RESOLVED_VIRTUAL_SERVER_HOOKS_ID = `\0${VIRTUAL_SERVER_HOOKS_ID}`;
@@ -18,62 +17,21 @@ const findStaticImportInsertPosition = (sourceCode) => {
     }
     return lastMatch ? lastMatch.index + lastMatch[0].length : 0;
 };
-const createVirtualServerHooks = (silentChromeDevtools) => `// ${GENERATED_MARKER}
-import { edgesHandle, edgesHandleRaw } from '${VIRTUAL_SERVER_UTILS_ID}';
-import { RequestContext } from '@azure-net/kit/server-context';
-
+const createVirtualServerHooks = () => `// ${GENERATED_MARKER}
+import { runRequest } from '@azure-net/kit/internal/server';
+import { render } from 'svelte/server';
 const getRegister = async () => (await import('${VIRTUAL_PROGRAM_ID}')).register;
-
-const withRequestContext = (event, callback) => {
-	try {
-		RequestContext.current();
-	} catch {
-		return edgesHandleRaw(event, callback);
-	}
-
-	return callback();
+export const init = async () => {
+	// Initialize Svelte's cached async-render promise outside any request ALS scope.
+	await render(() => {});
+	return (await getRegister()).serverInit();
 };
-
-export const init = async () => (await getRegister()).serverInit();
-export const handleFetch = (input) => withRequestContext(input.event, async () => (await getRegister()).serverFetch(input));
-export const handleValidationError = (input) => withRequestContext(
-	input.event,
-	async () => (await getRegister()).serverValidationError(input)
-);
+export const handle = (input) => runRequest(input.event, async () => (await getRegister()).handle(input));
+export const handleFetch = (input) => runRequest(input.event, async () => (await getRegister()).serverFetch(input));
+export const handleError = (input) => runRequest(input.event, async () => (await getRegister()).serverError(input));
 export const reroute = async (input) => (await getRegister()).reroute(input);
 export const getTransport = async () => (await getRegister()).transport;
-
-export const handle = edgesHandle(async ({ serialize, edgesEvent, resolve }) => {
-	const register = await getRegister();
-
-	return register.handle({
-		event: edgesEvent,
-		resolve: (event, options) =>
-			resolve(event, {
-				...options,
-				transformPageChunk: async (chunk) => {
-					const html = (options?.transformPageChunk ? await options.transformPageChunk(chunk) : undefined) ?? chunk.html;
-					return serialize(html);
-				}
-			})
-	});
-}
-${silentChromeDevtools ? ')' : ', false)'};
-
-export const handleError = async ({ error, event, status, message }) => {
-	let result;
-
-	await edgesHandleRaw(event, async () => {
-		const register = await getRegister();
-		result = await register.serverError({ error, event, status, message });
-
-		return new Response(null, { status: 204 });
-	});
-
-	return result;
-};
 `;
-const createVirtualServerUtils = () => "export { edgesHandle, edgesHandleRaw } from '@azure-net/kit/edges/internal-package/utils';";
 const createVirtualClientHooks = () => `// ${GENERATED_MARKER}
 const getRegister = async () => (await import('${VIRTUAL_PROGRAM_ID}')).register;
 
@@ -155,7 +113,6 @@ const transformGeneratedServerInternal = (sourceCode) => {
 \t\thandle: __azureNetServerHooks.handle,
 \t\thandleFetch: __azureNetServerHooks.handleFetch,
 \t\thandleError: __azureNetServerHooks.handleError,
-\t\thandleValidationError: __azureNetServerHooks.handleValidationError,
 \t\tinit: __azureNetServerHooks.init,
 \t\treroute: __azureNetServerHooks.reroute,
 \t\ttransport: await __azureNetServerHooks.getTransport()
@@ -170,7 +127,7 @@ const transformGeneratedClientApp = (sourceCode) => {
     if (/hooks\.client\.(?:ts|js)/.test(sourceCode)) {
         throw new Error('[AzureNetPlugin] SvelteKit detected a user-managed hooks.client file. Move its lifecycle code to src/program.ts via createApp().');
     }
-    const handleErrorPattern = /handleError:\s*\(\(\{\s*error\s*\}\)\s*=>\s*\{\s*console\.error\(error\)\s*\}\)/m;
+    const handleErrorPattern = /handleError:\s*\(\(\{\s*(?:kind,\s*)?error\s*\}\)\s*=>\s*\{\s*(?:if\s*\(kind === ['"]unknown['"]\)\s*\{\s*)?console\.error\(error\);?\s*\}\s*(?:\}\s*)?\)/m;
     if (!handleErrorPattern.test(sourceCode)) {
         throw new Error('[AzureNetPlugin] Unsupported SvelteKit generated client app: default handleError was not found.');
     }
@@ -193,8 +150,7 @@ const transformGeneratedClientApp = (sourceCode) => {
     transformed = transformed.replace(encodersPattern, 'export const encoders = __azureNetClientHooks.encoders;');
     return transformed;
 };
-export const AzureNetPlugin = (options) => {
-    const { silentChromeDevtools = true } = options ?? {};
+export const AzureNetPlugin = () => {
     let root = process.cwd();
     return {
         name: 'azure-net-kit-plugin',
@@ -214,8 +170,10 @@ export const AzureNetPlugin = (options) => {
             assertProgramExists(root);
         },
         resolveId(id) {
-            if (id === VIRTUAL_SERVER_UTILS_ID)
-                return RESOLVED_VIRTUAL_SERVER_UTILS_ID;
+            if (id === '@azure-net/kit/internal/server') {
+                const runtime = fileURLToPath(new URL('../server/Context/Runtime.js', import.meta.url));
+                return fs.existsSync(runtime) ? runtime : runtime.replace(/\.js$/, '.ts');
+            }
             if (id === VIRTUAL_SERVER_HOOKS_ID)
                 return RESOLVED_VIRTUAL_SERVER_HOOKS_ID;
             if (id === VIRTUAL_CLIENT_HOOKS_ID)
@@ -225,10 +183,8 @@ export const AzureNetPlugin = (options) => {
             return null;
         },
         load(id) {
-            if (id === RESOLVED_VIRTUAL_SERVER_UTILS_ID)
-                return createVirtualServerUtils();
             if (id === RESOLVED_VIRTUAL_SERVER_HOOKS_ID)
-                return createVirtualServerHooks(silentChromeDevtools);
+                return createVirtualServerHooks();
             if (id === RESOLVED_VIRTUAL_CLIENT_HOOKS_ID)
                 return createVirtualClientHooks();
             if (id === RESOLVED_VIRTUAL_PROGRAM_ID)
@@ -237,11 +193,12 @@ export const AzureNetPlugin = (options) => {
         },
         transform(code, id) {
             const normalizedId = id.split('?')[0].split(path.sep).join('/');
-            if (normalizedId.endsWith('/.svelte-kit/generated/server/internal.js')) {
+            if (normalizedId.endsWith('/.svelte-kit/generated/server/internal.js') ||
+                /\/.svelte-kit\/generated\/(?:build|dev)\/server\.js$/.test(normalizedId)) {
                 const transformed = transformGeneratedServerInternal(code);
                 return transformed ? { code: transformed, map: null } : null;
             }
-            if (normalizedId.endsWith('/.svelte-kit/generated/client/app.js') || normalizedId.endsWith('/.svelte-kit/generated/client-optimized/app.js')) {
+            if (/\/.svelte-kit\/generated\/(?:(?:build|dev)\/)?client(?:-optimized)?\/app\.js$/.test(normalizedId)) {
                 const transformed = transformGeneratedClientApp(code);
                 return transformed ? { code: transformed, map: null } : null;
             }

package/dist/plugin/index.d.ts

@@ -1 +1 @@
-export { AzureNetPlugin, type AzureNetPluginOptions } from './AzureNetPlugin.js';
+export { AzureNetPlugin } from './AzureNetPlugin.js';

package/dist/server/Context/Runtime.d.ts

@@ -0,0 +1,3 @@
+import '$app/server';
+import type { RequestEvent } from '@sveltejs/kit';
+export declare function runRequest<T>(event: RequestEvent, callback: () => T): T;

package/dist/server/Context/Runtime.js

@@ -0,0 +1,109 @@
+import '$app/server';
+import { AsyncLocalStorage } from 'node:async_hooks';
+import { initializeRequestContext, getContextInternals } from '../../shared/request-context/Internal.js';
+// Cached import promises may retain their ALS store forever. The store must not
+// strongly own a completed request, while pending work still needs a live context.
+const storage = new AsyncLocalStorage();
+const contexts = new WeakMap();
+const scopes = new WeakMap();
+const currentContext = () => storage.getStore()?.ref.deref();
+initializeRequestContext(currentContext);
+function release(scope) {
+    if (--scope.leases === 0)
+        scope.active = undefined;
+}
+function retainResponse(response, scope) {
+    if (!response.body)
+        return response;
+    let reader = response.body.getReader();
+    // Keep this lease on the stream, not the ALS store: abandoned responses must
+    // also be collectible without requiring callers to explicitly consume them.
+    let context = scope.active;
+    const finish = () => {
+        if (!reader)
+            return;
+        reader.releaseLock();
+        reader = undefined;
+        context = undefined;
+    };
+    const body = new ReadableStream({
+        async pull(controller) {
+            if (!context || !reader)
+                return;
+            try {
+                const chunk = await storage.run(scope, () => reader.read());
+                if (chunk.done) {
+                    finish();
+                    controller.close();
+                }
+                else
+                    controller.enqueue(chunk.value);
+            }
+            catch (error) {
+                finish();
+                controller.error(error);
+            }
+        },
+        async cancel(reason) {
+            try {
+                await storage.run(scope, () => reader?.cancel(reason));
+            }
+            finally {
+                finish();
+            }
+        }
+    });
+    const retained = new Response(body, { status: response.status, statusText: response.statusText, headers: response.headers });
+    // Fetch response metadata is not copied by the Response constructor.
+    Object.defineProperties(retained, {
+        url: { value: response.url },
+        redirected: { value: response.redirected },
+        type: { value: response.type }
+    });
+    return retained;
+}
+function complete(value, scope) {
+    try {
+        return (value instanceof Response ? retainResponse(value, scope) : value);
+    }
+    finally {
+        release(scope);
+    }
+}
+function invoke(scope, callback) {
+    let value;
+    let promise;
+    try {
+        value = callback();
+        if (value && typeof value.then === 'function')
+            promise = Promise.resolve(value);
+    }
+    catch (error) {
+        release(scope);
+        throw error;
+    }
+    if (promise) {
+        return promise.then((result) => complete(result, scope), (error) => {
+            release(scope);
+            throw error;
+        });
+    }
+    return complete(value, scope);
+}
+export function runRequest(event, callback) {
+    initializeRequestContext(currentContext);
+    let context = contexts.get(event);
+    if (!context) {
+        context = Object.freeze({ event, state: {} });
+        contexts.set(event, context);
+        getContextInternals(context).requestId = Symbol('request');
+    }
+    let scope = scopes.get(context);
+    if (!scope) {
+        scope = { ref: new WeakRef(context), leases: 0 };
+        scopes.set(context, scope);
+    }
+    scope.active = context;
+    scope.leases++;
+    return storage.run(scope, () => invoke(scope, callback));
+}

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

@@ -1,74 +1,44 @@
-import { type ContextData } from '../../external/edges/ServerContext.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 { 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';
+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 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 AppDependencyFactory<TApp, TReturn = unknown> = (app: TApp) => TReturn;
-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' | '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 BuilderDependencies<TBuilder> = TBuilder extends {
-    readonly __types__?: infer TDependencies;
-} ? TDependencies : never;
 type OnceMethod<TFlags extends BuilderFlags, TKey extends keyof BuilderFlags, TMethod> = TFlags[TKey] extends true ? object : TMethod;
-export type AppContainer<TDependencies extends Record<string, unknown>> = Readonly<TDependencies>;
-export interface AppUniversalLifecycleContext<TDependencies extends Record<string, unknown>> {
-    Container: AppContainer<TDependencies>;
+export interface AppUniversalLifecycleContext {
     isClient: boolean;
     isServer: boolean;
     requestContext?: ContextData;
     event?: RequestEvent;
 }
-export interface AppClientLifecycleContext<TDependencies extends Record<string, unknown>> {
-    Container: AppContainer<TDependencies>;
-    useMiddlewares: (middlewares: IClientMiddleware[]) => void;
-}
-export interface AppClientInitLifecycleContext<TDependencies extends Record<string, unknown>> {
-    Container: AppContainer<TDependencies>;
-}
-export interface AppClientErrorContext<TDependencies extends Record<string, unknown>> extends Omit<AppClientLifecycleContext<TDependencies>, 'useMiddlewares'> {
-    error: unknown;
-    event: Parameters<HandleClientError>[0]['event'];
-    status: number;
-    message: string;
+export interface AppClientLifecycleContext {
+    useMiddlewares: (middlewares: readonly ClientMiddlewareClass[]) => void;
 }
+export type AppClientInitLifecycleContext = void;
+export type AppClientErrorContext = Parameters<HandleClientError>[0];
 export type AppServerInitLifecycleContext = void;
-export interface AppServerLifecycleContext<TDependencies extends Record<string, unknown>> {
-    Container: AppContainer<TDependencies>;
+export interface AppServerLifecycleContext {
     requestContext: ContextData;
     event: RequestEvent;
     resolve: Resolve;
-    useMiddlewares: (middlewares: IServerMiddleware[]) => Promise<void>;
+    useMiddlewares: (middlewares: readonly ServerMiddlewareClass[]) => Promise<void>;
 }
-export interface AppServerErrorContext<TDependencies extends Record<string, unknown>> {
-    Container: AppContainer<TDependencies>;
+export type AppServerErrorContext = Parameters<HandleServerError>[0] & {
     requestContext: ContextData;
-    error: unknown;
-    event: RequestEvent;
-    status: number;
-    message: string;
     useLogger: typeof useLogger;
-}
-export type AppServerFetchContext<TDependencies extends Record<string, unknown>> = Parameters<HandleFetch>[0] & {
-    Container: AppContainer<TDependencies>;
-    requestContext: ContextData;
 };
-export type AppServerValidationErrorContext<TDependencies extends Record<string, unknown>> = Parameters<HandleValidationError>[0] & {
-    Container: AppContainer<TDependencies>;
+export type AppServerFetchContext = Parameters<HandleFetch>[0] & {
     requestContext: ContextData;
 };
-export interface AppAzureNetKitErrorContext<TDependencies extends Record<string, unknown>> {
-    Container: AppContainer<TDependencies>;
-    AppEvents: typeof AppEvents;
+export interface AppAzureNetKitErrorContext {
     error: AppError;
     retry: AsyncHelperRetry;
     isClient: boolean;
@@ -76,44 +46,46 @@ export interface AppAzureNetKitErrorContext<TDependencies extends Record<string,
     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>;
-export type AppClientErrorCallback<TDependencies extends Record<string, unknown>> = (context: AppClientErrorContext<TDependencies>) => ReturnType<HandleClientError>;
+export type AppUniversalLifecycleCallback = (context: AppUniversalLifecycleContext) => MaybePromise<void>;
+export type AppClientLifecycleCallback = (context: AppClientLifecycleContext) => MaybePromise<void>;
+export type AppClientInitLifecycleCallback = (context: AppClientInitLifecycleContext) => MaybePromise<void>;
+export type AppClientErrorCallback = (context: AppClientErrorContext) => ReturnType<HandleClientError>;
 export type AppServerInitLifecycleCallback = ServerInit;
-export type AppServerLifecycleCallback<TDependencies extends Record<string, unknown>> = (context: AppServerLifecycleContext<TDependencies>) => MaybePromise<Response | void>;
-export type AppServerErrorCallback<TDependencies extends Record<string, unknown>> = (context: AppServerErrorContext<TDependencies>) => ReturnType<HandleServerError>;
-export type AppServerFetchCallback<TDependencies extends Record<string, unknown>> = (context: AppServerFetchContext<TDependencies>) => ReturnType<HandleFetch>;
-export type AppServerValidationErrorCallback<TDependencies extends Record<string, unknown>> = (context: AppServerValidationErrorContext<TDependencies>) => ReturnType<HandleValidationError>;
-export type AppAzureNetKitErrorCallback<TDependencies extends Record<string, unknown>> = (context: AppAzureNetKitErrorContext<TDependencies>) => MaybePromise<IAppError & object>;
+export type AppServerLifecycleCallback = (context: AppServerLifecycleContext) => MaybePromise<Response | void>;
+export type AppServerErrorCallback = (context: AppServerErrorContext) => ReturnType<HandleServerError>;
+export type AppServerFetchCallback = (context: AppServerFetchContext) => ReturnType<HandleFetch>;
+export type AppAzureNetKitErrorCallback = (context: AppAzureNetKitErrorContext) => MaybePromise<IAppError & object>;
 export type AppRerouteCallback = Reroute;
-export type CreateAppBuilder<TDependencies extends Record<string, unknown>, TFlags extends BuilderFlags = object> = {
-    readonly __types__?: TDependencies;
-    dependencies<TNext extends AppDependencyFactories<AppContainer<TDependencies>>>(dependencies: TNext): CreateAppBuilder<TDependencies & ResolvedDependencies<TNext>, TFlags>;
-} & OnceMethod<TFlags, 'use', {
-    use(callback: AppUniversalLifecycleCallback<TDependencies>): CreateAppBuilder<TDependencies, WithFlag<TFlags, 'use'>>;
+export interface AppBootContext {
+    state: App.RequestContextState;
+}
+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: TranslationManagerSource): CreateAppBuilder<WithFlag<TFlags, 'useTranslations'>>;
+}> & OnceMethod<TFlags, 'use', {
+    use(callback: AppUniversalLifecycleCallback): CreateAppBuilder<WithFlag<TFlags, 'use'>>;
 }> & OnceMethod<TFlags, 'useClient', {
-    useClient(callback: AppClientLifecycleCallback<TDependencies>): CreateAppBuilder<TDependencies, WithFlag<TFlags, 'useClient'>>;
+    useClient(callback: AppClientLifecycleCallback): CreateAppBuilder<WithFlag<TFlags, 'useClient'>>;
 }> & OnceMethod<TFlags, 'useClientInit', {
-    useClientInit(callback: AppClientInitLifecycleCallback<TDependencies>): CreateAppBuilder<TDependencies, WithFlag<TFlags, 'useClientInit'>>;
+    useClientInit(callback: AppClientInitLifecycleCallback): CreateAppBuilder<WithFlag<TFlags, 'useClientInit'>>;
 }> & OnceMethod<TFlags, 'useClientError', {
-    useClientError(callback: AppClientErrorCallback<TDependencies>): CreateAppBuilder<TDependencies, WithFlag<TFlags, 'useClientError'>>;
+    useClientError(callback: AppClientErrorCallback): CreateAppBuilder<WithFlag<TFlags, 'useClientError'>>;
 }> & OnceMethod<TFlags, 'useServerInit', {
-    useServerInit(callback: AppServerInitLifecycleCallback): CreateAppBuilder<TDependencies, WithFlag<TFlags, 'useServerInit'>>;
+    useServerInit(callback: AppServerInitLifecycleCallback): CreateAppBuilder<WithFlag<TFlags, 'useServerInit'>>;
 }> & OnceMethod<TFlags, 'useServer', {
-    useServer(callback: AppServerLifecycleCallback<TDependencies>): CreateAppBuilder<TDependencies, WithFlag<TFlags, 'useServer'>>;
+    useServer(callback: AppServerLifecycleCallback): CreateAppBuilder<WithFlag<TFlags, 'useServer'>>;
 }> & OnceMethod<TFlags, 'useServerError', {
-    useServerError(callback: AppServerErrorCallback<TDependencies>): CreateAppBuilder<TDependencies, WithFlag<TFlags, 'useServerError'>>;
+    useServerError(callback: AppServerErrorCallback): CreateAppBuilder<WithFlag<TFlags, 'useServerError'>>;
 }> & OnceMethod<TFlags, 'useServerFetch', {
-    useServerFetch(callback: AppServerFetchCallback<TDependencies>): CreateAppBuilder<TDependencies, WithFlag<TFlags, 'useServerFetch'>>;
-}> & OnceMethod<TFlags, 'useServerValidationError', {
-    useServerValidationError(callback: AppServerValidationErrorCallback<TDependencies>): CreateAppBuilder<TDependencies, WithFlag<TFlags, 'useServerValidationError'>>;
+    useServerFetch(callback: AppServerFetchCallback): CreateAppBuilder<WithFlag<TFlags, 'useServerFetch'>>;
 }> & OnceMethod<TFlags, 'useAzureNetKitError', {
-    useAzureNetKitError(callback: AppAzureNetKitErrorCallback<TDependencies>): CreateAppBuilder<TDependencies, WithFlag<TFlags, 'useAzureNetKitError'>>;
+    useAzureNetKitError(callback: AppAzureNetKitErrorCallback): CreateAppBuilder<WithFlag<TFlags, 'useAzureNetKitError'>>;
 }> & OnceMethod<TFlags, 'useReroute', {
-    useReroute(callback: AppRerouteCallback): CreateAppBuilder<TDependencies, WithFlag<TFlags, 'useReroute'>>;
+    useReroute(callback: AppRerouteCallback): CreateAppBuilder<WithFlag<TFlags, 'useReroute'>>;
 }> & OnceMethod<TFlags, 'useTransport', {
-    useTransport(transport: Transport): CreateAppBuilder<TDependencies, WithFlag<TFlags, 'useTransport'>>;
+    useTransport(transport: Transport): CreateAppBuilder<WithFlag<TFlags, 'useTransport'>>;
 }>;
 export interface AppRegistrar {
     (): MaybePromise<void>;
@@ -122,14 +94,12 @@ export interface AppRegistrar {
     serverInit: ServerInit;
     serverError: HandleServerError;
     serverFetch: HandleFetch;
-    serverValidationError: HandleValidationError;
     handle: Handle;
     reroute: Reroute;
     transport: Transport;
 }
-export interface CreateAppInstance<TDependencies extends Record<string, unknown>> {
-    Container: AppContainer<TDependencies>;
+export interface CreateAppInstance {
     register: AppRegistrar;
 }
-export declare const createApp: <TBuilder>(callback: (app: CreateAppBuilder<Record<string, never>>) => TBuilder, name?: string) => CreateAppInstance<BuilderDependencies<TBuilder> & Record<string, unknown>>;
+export declare const createApp: (callback: (app: CreateAppBuilder) => unknown) => CreateAppInstance;
 export {};