@azure-net/kit 6.0.0-next → 6.0.0-next.2

package/dist/shared/app/App.js

@@ -1,14 +1,23 @@
+import { getTranslationLifecycle } from '../../i18n/Internal.js';
+import { hydratable } from 'svelte';
+import { getContextInternals } from '../../shared/request-context/Internal.js';
 import { BROWSER } from '../../external/tools/index.js';
-import { RequestContext } from '../../external/edges/ServerContext.js';
-import { createBoundaryProvider } from '../boundary-provider/Provider.js';
+import { RequestContext } from '../../shared/request-context/Internal.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';
 import { useLogger } from '../logger/index.js';
-const DEFAULT_APP_NAME = '__AzureNetKitGlobalAppContainer__';
+// Kit 3 nests safe status/message inside caught errors; unknown errors keep safe defaults.
+const errorDetails = (input) => {
+    const legacy = input;
+    const error = input.kind !== 'unknown' && input.error && typeof input.error === 'object' ? input.error : {};
+    return {
+        status: typeof legacy.status === 'number' ? legacy.status : typeof error.status === 'number' ? error.status : 500,
+        message: typeof legacy.message === 'string' ? legacy.message : typeof error.message === 'string' ? error.message : 'Internal Error'
+    };
+};
 const clientLifecycleFlags = new WeakMap();
 const getRequestContext = () => {
     try {
@@ -37,7 +46,7 @@ const getLifecycleFlags = (appKey, requestContext) => {
     if (!context) {
         throw new AzureNetKitInternalError('[createApp] RequestContext is not initialized on server.');
     }
-    const flagsMap = (context.data.appLifecycleFlags ??= new WeakMap());
+    const flagsMap = (getContextInternals(context).appLifecycleFlags ??= new WeakMap());
     let flags = flagsMap.get(appKey);
     if (!flags) {
         flags = {};
@@ -51,8 +60,16 @@ const setCallback = (callbacks, key, callback) => {
     }
     callbacks[key] = callback;
 };
-const createBuilder = (dependencies, callbacks) => {
+const createBuilder = (callbacks) => {
     const builder = {
+        useTranslations(manager) {
+            setCallback(callbacks, 'useTranslations', manager);
+            return builder;
+        },
+        useBoot(callback) {
+            setCallback(callbacks, 'useBoot', callback);
+            return builder;
+        },
         use(callback) {
             setCallback(callbacks, 'use', callback);
             return builder;
@@ -85,10 +102,6 @@ const createBuilder = (dependencies, callbacks) => {
             setCallback(callbacks, 'useServerFetch', callback);
             return builder;
         },
-        useServerValidationError(callback) {
-            setCallback(callbacks, 'useServerValidationError', callback);
-            return builder;
-        },
         useAzureNetKitError(callback) {
             setCallback(callbacks, 'useAzureNetKitError', callback);
             return builder;
@@ -100,60 +113,21 @@ const createBuilder = (dependencies, callbacks) => {
         useTransport(transport) {
             setCallback(callbacks, 'useTransport', transport);
             return builder;
-        },
-        dependencies(nextDependencies) {
-            for (const [key, factory] of Object.entries(nextDependencies)) {
-                dependencies.set(key, factory);
-            }
-            return builder;
         }
     };
     return builder;
 };
-export const createApp = (callback, name = DEFAULT_APP_NAME) => {
+export const createApp = (callback) => {
     const appKey = {};
-    const dependencies = new Map();
     const callbacks = {};
     let clientInitialized = false;
+    let translationInitPromise;
     let serverInitPromise;
-    callback(createBuilder(dependencies, callbacks));
-    const AppProvider = createBoundaryProvider(name, {
-        register: () => {
-            const factories = {};
-            for (const [key, factory] of dependencies.entries()) {
-                factories[key] = () => factory(Container);
-            }
-            return factories;
-        }
-    });
-    const Container = new Proxy({}, {
-        get(_, key) {
-            if (typeof key === 'symbol')
-                return undefined;
-            return AppProvider()[key];
-        },
-        has(_, key) {
-            return typeof key === 'string' && key in AppProvider();
-        },
-        ownKeys() {
-            return Reflect.ownKeys(AppProvider());
-        },
-        getOwnPropertyDescriptor(_, key) {
-            if (typeof key !== 'string' || !(key in AppProvider()))
-                return undefined;
-            return {
-                configurable: true,
-                enumerable: true,
-                value: AppProvider()[key]
-            };
-        }
-    });
+    callback(createBuilder(callbacks));
     const errorResolver = callbacks.useAzureNetKitError
         ? (error, retry) => {
             const requestContext = BROWSER ? undefined : getRequestContext();
             return callbacks.useAzureNetKitError({
-                Container,
-                AppEvents,
                 error,
                 retry,
                 isClient: BROWSER,
@@ -172,39 +146,44 @@ export const createApp = (callback, name = DEFAULT_APP_NAME) => {
         bindErrorResolver();
         const flags = getLifecycleFlags(appKey);
         if (flags[kind])
-            return undefined;
+            return kind === 'clientInit' ? translationInitPromise : undefined;
         flags[kind] = true;
         if (kind === 'clientInit') {
-            const universalContext = {
-                Container,
-                isClient: true,
-                isServer: false
+            const initialize = () => {
+                const universalContext = {
+                    isClient: true,
+                    isServer: false
+                };
+                const universalResult = callbacks.use?.(universalContext);
+                if (universalResult && typeof universalResult.then === 'function') {
+                    return universalResult.then(() => callbacks.useClientInit?.());
+                }
+                return callbacks.useClientInit?.();
             };
-            const universalResult = callbacks.use?.(universalContext);
-            if (universalResult && typeof universalResult.then === 'function') {
-                return universalResult.then(() => callbacks.useClientInit?.({ Container }));
-            }
-            return callbacks.useClientInit?.({ Container });
+            if (!callbacks.useTranslations)
+                return initialize();
+            translationInitPromise = getTranslationLifecycle(callbacks.useTranslations())
+                .initializeClient()
+                .then(initialize)
+                .catch((error) => {
+                delete flags.clientInit;
+                translationInitPromise = undefined;
+                throw error;
+            });
+            return translationInitPromise;
         }
         let internalMiddlewares = [];
-        const clientResult = callbacks.useClient?.({
-            Container,
-            useMiddlewares: (middlewares) => {
-                internalMiddlewares = middlewares;
-            }
-        });
-        const registerNavigation = () => {
-            if (clientInitialized)
-                return;
-            clientInitialized = true;
+        if (!clientInitialized) {
             beforeNavigate((navigation) => {
                 executeClientMiddlewares(internalMiddlewares, navigation);
             });
-        };
-        if (clientResult && typeof clientResult.then === 'function') {
-            return clientResult.then(registerNavigation);
+            clientInitialized = true;
         }
-        registerNavigation();
+        return callbacks.useClient?.({
+            useMiddlewares: (middlewares) => {
+                internalMiddlewares = middlewares;
+            }
+        });
     };
     const runServerInit = () => {
         if (BROWSER)
@@ -212,17 +191,16 @@ export const createApp = (callback, name = DEFAULT_APP_NAME) => {
         serverInitPromise ??= Promise.resolve().then(() => callbacks.useServerInit?.());
         return serverInitPromise;
     };
-    const runServerError = ({ error, event, status, message }) => {
+    const runServerError = (input) => {
+        const { status, message } = errorDetails(input);
         if (BROWSER)
             return undefined;
         const requestContext = getServerRequestContext();
         bindErrorResolver(requestContext);
         try {
             const result = callbacks.useServerError?.({
-                Container,
                 requestContext,
-                error,
-                event,
+                ...input,
                 status,
                 message,
                 useLogger
@@ -238,14 +216,13 @@ export const createApp = (callback, name = DEFAULT_APP_NAME) => {
             throw error;
         }
     };
-    const runClientError = ({ error, event, status, message }) => {
+    const runClientError = (input) => {
+        const { status, message } = errorDetails(input);
         if (!BROWSER)
             return undefined;
         bindErrorResolver();
         return callbacks.useClientError?.({
-            Container,
-            error,
-            event,
+            ...input,
             status,
             message
         });
@@ -255,31 +232,27 @@ export const createApp = (callback, name = DEFAULT_APP_NAME) => {
             return input.fetch(input.request);
         return callbacks.useServerFetch({
             ...input,
-            Container,
-            requestContext: getServerRequestContext()
-        });
-    };
-    const runServerValidationError = (input) => {
-        if (!callbacks.useServerValidationError) {
-            console.error('Remote function schema validation failed:', input.issues);
-            return { message: 'Bad Request' };
-        }
-        return callbacks.useServerValidationError({
-            ...input,
-            Container,
             requestContext: getServerRequestContext()
         });
     };
     const reroute = (input) => callbacks.useReroute?.(input);
-    const handle = async ({ event, resolve }) => {
+    const handle = async ({ event, resolve: originalResolve }) => {
+        const translations = callbacks.useTranslations ? getTranslationLifecycle(callbacks.useTranslations()) : undefined;
+        const resolve = translations
+            ? (event, options) => originalResolve(event, {
+                ...options,
+                transformPageChunk: async (chunk) => translations.transformHtml((await options?.transformPageChunk?.(chunk)) ?? chunk.html)
+            })
+            : originalResolve;
         const requestContext = getServerRequestContext();
         bindErrorResolver(requestContext);
         try {
             const flags = getLifecycleFlags(appKey, requestContext);
             if (!flags.server) {
                 flags.server = true;
+                if (translations)
+                    await translations.preloadTranslation();
                 const universalResult = callbacks.use?.({
-                    Container,
                     isClient: false,
                     isServer: true,
                     requestContext,
@@ -289,7 +262,6 @@ export const createApp = (callback, name = DEFAULT_APP_NAME) => {
                     await universalResult;
                 }
                 const serverResult = await callbacks.useServer?.({
-                    Container,
                     requestContext,
                     event,
                     resolve,
@@ -304,19 +276,36 @@ export const createApp = (callback, name = DEFAULT_APP_NAME) => {
             bindAzureNetKitErrorResolver(undefined, requestContext);
         }
     };
-    const register = Object.assign(() => runClient('client'), {
+    const runBoot = () => {
+        if (!callbacks.useBoot && !callbacks.useTranslations)
+            return;
+        const flags = getLifecycleFlags(appKey);
+        if (flags.boot)
+            return;
+        flags.boot = true;
+        const state = hydratable('@azure-net/kit:initial-state:v1', () => (BROWSER ? {} : RequestContext.current().state));
+        if (callbacks.useTranslations)
+            getTranslationLifecycle(callbacks.useTranslations()).syncFromState(state);
+        const result = callbacks.useBoot?.({ state });
+        if (result && typeof result.then === 'function') {
+            void Promise.resolve(result).catch(() => undefined);
+            throw new AzureNetKitInternalError('[createApp] useBoot must be synchronous.');
+        }
+    };
+    const register = Object.assign(() => {
+        runBoot();
+        return runClient('client');
+    }, {
         clientInit: () => runClient('clientInit'),
         clientError: runClientError,
         serverInit: runServerInit,
         serverError: runServerError,
         serverFetch: runServerFetch,
-        serverValidationError: runServerValidationError,
         handle,
         reroute,
         transport: callbacks.useTransport ?? {}
     });
     return {
-        Container,
         register
     };
 };

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

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

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

@@ -1,6 +1,6 @@
-import { type BeforeNavigate } from '@sveltejs/kit';
 import { type EnsureRoute } from './Shared.js';
-import type { RedirectStatus } from '../../redirect/index.js';
+import type { RedirectStatus } from '../../../svelte/redirect/index.js';
+import type { BeforeNavigate } from '$app/navigation';
 export type IClientMiddleware = (middlewareData: {
     to: URL;
     from?: URL;

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

@@ -1,4 +1,3 @@
-import {} from '@sveltejs/kit';
 import { ensureRoute } from './Shared.js';
 import { page } from '$app/state';
 import { goto } from '$app/navigation';

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

@@ -1,6 +1,6 @@
 import { type RequestEvent } from '@sveltejs/kit';
 import { type EnsureRoute } from './Shared.js';
-import type { RedirectStatus } from '../../redirect/index.js';
+import type { RedirectStatus } from '../../../svelte/redirect/index.js';
 export type IServerMiddleware = (middlewareData: {
     to: RequestEvent['url'];
     from?: RequestEvent['url'];

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

@@ -1,7 +1,7 @@
 import { error, redirect } from '@sveltejs/kit';
 import { ensureRoute } from './Shared.js';
 import { BROWSER } from '../../../external/tools/index.js';
-import { RequestContext } from '../../../external/edges/ServerContext.js';
+import { RequestContext } from '../../../shared/request-context/Internal.js';
 export const executeServerMiddlewares = async (middlewares) => {
     if (!BROWSER && middlewares.length) {
         const event = RequestContext.current().event;

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

@@ -1,4 +1,4 @@
-import { type ContextData } from '../../external/edges/ServerContext.js';
+import { type ContextData } from '../../shared/request-context/Internal.js';
 import { AppError, type IAppError } from './AppError.js';
 type MaybePromise<T> = T | Promise<T>;
 export interface AsyncHelperRetry {

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

@@ -1,14 +1,15 @@
+import { getContextInternals } from '../../shared/request-context/Internal.js';
 import { BROWSER } from '../../external/tools/index.js';
-import { RequestContext } from '../../external/edges/ServerContext.js';
+import { RequestContext } from '../../shared/request-context/Internal.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;
+        return getContextInternals(requestContext);
     try {
-        return RequestContext.current().data;
+        return getContextInternals(RequestContext.current());
     }
     catch {
         return undefined;

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

@@ -13,9 +13,9 @@ 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>;
+export declare const CreateDiContainer: <T extends ServiceMap, D extends Record<string, ProviderWithType<ServiceMap>>>(name: string, settings: ProviderSettings<T, D>) => ProviderWithType<T>;
 export declare function cleanupProvider(name: string): Promise<void>;
 export {};

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

@@ -1,4 +1,5 @@
-import { RequestContext } from '../../external/edges/ServerContext.js';
+import { getContextInternals } from '../../shared/request-context/Internal.js';
+import { RequestContext } from '../../shared/request-context/Internal.js';
 import { BROWSER } from '../../external/tools/index.js';
 import { AzureNetKitInternalError } from '../app-error/AppError.js';
 const clientCache = new Map();
@@ -14,30 +15,36 @@ const getProviderCache = (providerName) => {
     }
     else {
         const context = RequestContext.current();
-        if (!context.data.providers) {
-            context.data.providers = new Map();
+        if (!getContextInternals(context).azureNetKitBoundaryProviders) {
+            getContextInternals(context).azureNetKitBoundaryProviders = new Map();
         }
-        const providers = context.data.providers;
+        const providers = getContextInternals(context).azureNetKitBoundaryProviders;
         if (!providers.has(providerName)) {
             providers.set(providerName, new Map());
         }
-        if (!context.data.providersToCleanup) {
-            context.data.providersToCleanup = new Set();
+        if (!getContextInternals(context).azureNetKitBoundaryProvidersToCleanup) {
+            getContextInternals(context).azureNetKitBoundaryProvidersToCleanup = new Set();
         }
-        context.data.providersToCleanup.add(providerName);
+        getContextInternals(context).azureNetKitBoundaryProvidersToCleanup.add(providerName);
         return providers.get(providerName);
     }
 };
+const getProxyCache = () => {
+    if (BROWSER)
+        return providerProxyCache;
+    const context = RequestContext.current();
+    return (getContextInternals(context).azureNetKitBoundaryProviderProxies ??= new Map());
+};
 const getBootFlag = (providerName) => {
     if (BROWSER) {
         return clientBootFlags.get(providerName) ?? false;
     }
     else {
         const context = RequestContext.current();
-        if (!context.data.bootFlags) {
-            context.data.bootFlags = new Map();
+        if (!getContextInternals(context).bootFlags) {
+            getContextInternals(context).bootFlags = new Map();
         }
-        const bootFlags = context.data.bootFlags;
+        const bootFlags = getContextInternals(context).bootFlags;
         return bootFlags.get(providerName) ?? false;
     }
 };
@@ -47,10 +54,10 @@ const setBootFlag = (providerName, value) => {
     }
     else {
         const context = RequestContext.current();
-        if (!context.data.bootFlags) {
-            context.data.bootFlags = new Map();
+        if (!getContextInternals(context).bootFlags) {
+            getContextInternals(context).bootFlags = new Map();
         }
-        const bootFlags = context.data.bootFlags;
+        const bootFlags = getContextInternals(context).bootFlags;
         bootFlags.set(providerName, value);
     }
 };
@@ -58,7 +65,7 @@ const getConstructionStack = () => {
     if (BROWSER)
         return clientConstructionStack;
     const context = RequestContext.current();
-    return (context.data.boundaryProviderConstructionStack ??= []);
+    return (getContextInternals(context).boundaryProviderConstructionStack ??= []);
 };
 const runWithCycleGuard = (key, callback) => {
     const stack = getConstructionStack();
@@ -77,11 +84,12 @@ const runWithCycleGuard = (key, callback) => {
             stack.splice(idx, 1);
     }
 };
-export const createBoundaryProvider = (name, settings) => {
+export const CreateDiContainer = (name, settings) => {
     const { dependsOn = {}, boot, register } = settings;
     const providerFn = () => {
-        if (BROWSER && providerProxyCache.has(name)) {
-            return providerProxyCache.get(name);
+        const proxies = getProxyCache();
+        if (proxies.has(name)) {
+            return proxies.get(name);
         }
         const cache = getProviderCache(name);
         let factories = null;
@@ -101,7 +109,7 @@ export const createBoundaryProvider = (name, settings) => {
                     }
                 });
             }
-            factories = register(deps);
+            factories = runWithCycleGuard(`${name}.register`, () => register(deps));
             return factories;
         };
         const providerProxy = new Proxy({}, {
@@ -157,17 +165,22 @@ export const createBoundaryProvider = (name, settings) => {
                 };
             }
         });
-        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));
+        proxies.set(name, providerProxy);
+        try {
+            if (boot && !getBootFlag(name)) {
+                getFactories();
+                const bootResult = boot(providerProxy);
+                if (bootResult && typeof bootResult.then === 'function') {
+                    void Promise.resolve(bootResult).catch(() => undefined);
+                    throw new AzureNetKitInternalError(`[BoundaryProvider] Boot for provider '${name}' must be synchronous.`);
+                }
+                setBootFlag(name, true);
             }
         }
+        catch (error) {
+            proxies.delete(name);
+            throw error;
+        }
         return providerProxy;
     };
     return providerFn;
@@ -199,7 +212,10 @@ export async function cleanupProvider(name) {
     }
     else {
         const context = RequestContext.current();
-        const providers = context.data.providers;
+        const providers = getContextInternals(context).azureNetKitBoundaryProviders;
+        getProxyCache().delete(name);
+        setBootFlag(name, false);
+        getContextInternals(context).azureNetKitBoundaryProvidersToCleanup?.delete(name);
         if (providers?.has(name)) {
             const cache = providers.get(name);
             providers.delete(name);

package/dist/shared/cookie/UniversalCookie.js

@@ -1,5 +1,5 @@
 import { BROWSER, Cookies } from '../../external/tools/index.js';
-import { RequestContext } from '../../external/edges/ServerContext.js';
+import { RequestContext } from '../../shared/request-context/Internal.js';
 const cloneCookieOptions = (options) => ({
     ...options,
     expires: options.expires instanceof Date ? new Date(options.expires) : options.expires

package/dist/shared/index.d.ts

@@ -1,8 +1,6 @@
 export { UniversalCookie, UniversalCookieInstance, UniversalNamedCookieInstance, type CookieOptions } from './cookie/index.js';
 export { BackgroundTask } from './background-task/index.js';
-export { AppEvents } from './event-bus/index.js';
 export { ClassMirror } from './class-mirror/index.js';
-export { createBoundaryProvider, cleanupProvider, type ProviderSettings } from './boundary-provider/index.js';
+export { CreateDiContainer, cleanupProvider, type ProviderSettings } from './boundary-provider/index.js';
 export * from './app/index.js';
 export { useLogger, LoggerErrors, type ILoggerError, type ILoggerSettings } from './logger/index.js';
-export { useRedirect, type IRedirectSettings, type RedirectStatus } from './redirect/index.js';

package/dist/shared/index.js

@@ -1,8 +1,6 @@
 export { UniversalCookie, UniversalCookieInstance, UniversalNamedCookieInstance } from './cookie/index.js';
 export { BackgroundTask } from './background-task/index.js';
-export { AppEvents } from './event-bus/index.js';
 export { ClassMirror } from './class-mirror/index.js';
-export { createBoundaryProvider, cleanupProvider } from './boundary-provider/index.js';
+export { CreateDiContainer, cleanupProvider } from './boundary-provider/index.js';
 export * from './app/index.js';
 export { useLogger, LoggerErrors } from './logger/index.js';
-export { useRedirect } from './redirect/index.js';

package/dist/shared/logger/index.js

@@ -1,6 +1,6 @@
 import { AppError, AzureNetKitInternalError } from '../app-error/index.js';
 import { BROWSER } from '../../external/tools/index.js';
-import { RequestContext } from '../../external/edges/ServerContext.js';
+import { RequestContext } from '../../shared/request-context/Internal.js';
 import { BackgroundTask } from '../background-task/index.js';
 export var LoggerErrors;
 (function (LoggerErrors) {

package/dist/shared/request-context/Internal.d.ts

@@ -0,0 +1,16 @@
+import type { RequestEvent } from '@sveltejs/kit';
+declare global {
+    namespace App {
+        interface RequestContextState {
+        }
+    }
+}
+export interface ContextData {
+    readonly event: RequestEvent;
+    readonly state: App.RequestContextState;
+}
+export declare function initializeRequestContext(resolve: () => ContextData | undefined): void;
+export declare function getContextInternals(context: ContextData): Record<PropertyKey, unknown>;
+export declare const RequestContext: Readonly<{
+    current(): ContextData;
+}>;

package/dist/shared/request-context/Internal.js

@@ -0,0 +1,24 @@
+import { BROWSER } from '../../external/tools/index.js';
+let getter;
+const internals = new WeakMap();
+export function initializeRequestContext(resolve) {
+    getter = resolve;
+}
+export function getContextInternals(context) {
+    let data = internals.get(context);
+    if (!data) {
+        data = {};
+        internals.set(context, data);
+    }
+    return data;
+}
+export const RequestContext = Object.freeze({
+    current() {
+        if (BROWSER)
+            throw new Error('[AzureNetKit] RequestContext is server-only.');
+        const context = getter?.();
+        if (!context)
+            throw new Error('[AzureNetKit] No active RequestContext. Use AzureNetPlugin and resolve services inside a request.');
+        return context;
+    }
+});

package/dist/svelte/index.d.ts

@@ -2,3 +2,4 @@ export { createAsyncSignal, createAsyncSignalBatch, refreshAsyncSignal, refreshA
 export { createActiveForm, type ActiveForm, type ActiveFormCallbackContext, type ActiveFormController, type ActiveFormResponse, type ActiveFormStatus, type FormConfig, type InitialValuesHelpers, type LinkPromise, type LinkSignal, type LinkSignalOptions, type ResetBehaviors } from './active-form/ActiveForm.svelte.js';
 export { createEffect, type EffectCallback, type EffectCleanup, type EffectDependency } from './effect/Effect.svelte.js';
 export { createQuery, type CreateQueryOptions, type QueryController, type QueryPath, type QuerySearchParamsSync } from './query/Query.svelte.js';
+export { useRedirect, type IRedirectSettings, type RedirectStatus } from './redirect/index.js';

package/dist/svelte/index.js

@@ -2,3 +2,4 @@ export { createAsyncSignal, createAsyncSignalBatch, refreshAsyncSignal, refreshA
 export { createActiveForm } from './active-form/ActiveForm.svelte.js';
 export { createEffect } from './effect/Effect.svelte.js';
 export { createQuery } from './query/Query.svelte.js';
+export { useRedirect } from './redirect/index.js';