@useavalon/avalon 0.1.23 → 0.1.24

package/dist/src/core/islands/use-persistent-state.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Hook for persistent island state — like useState but survives navigations.
+ *
+ * State is serialized to sessionStorage (supports Date, Map, Set, RegExp).
+ * On the server or when storage is unavailable, falls back to in-memory state.
+ *
+ * ```tsx
+ * const [count, setCount, clearCount] = usePersistentState('my-counter', 0);
+ * ```
+ *
+ * @param id - Unique storage key for this piece of state
+ * @param initialValue - Default value when no persisted state exists
+ * @param options - Optional: `storage` ('session' | 'local'), defaults to 'session'
+ */
+export declare function usePersistentState<T>(id: string, initialValue: T, options?: {
+    storage?: 'session' | 'local';
+}): [T, (value: T | ((prev: T) => T)) => void, () => void];

package/dist/src/core/layout/enhanced-layout-resolver.d.ts

@@ -0,0 +1,73 @@
+import { LayoutDiscovery } from './layout-discovery.ts';
+import { LayoutMatcher } from './layout-matcher.ts';
+import { LayoutComposer } from './layout-composer.ts';
+import { LayoutDataLoader } from './layout-data-loader.ts';
+import { LayoutCacheManager } from './layout-cache-manager.ts';
+import type { LayoutContext, LayoutDiscoveryOptions, ResolvedLayout, PageModule } from './layout-types.ts';
+interface IEnhancedLayoutResolver {
+    resolveAndRender(routePath: string, pageModule: PageModule, context: LayoutContext): Promise<ResolvedLayout>;
+    getCachedResolution(routePath: string): ResolvedLayout | null;
+    clearCache(): void;
+    setCaching(enabled: boolean): void;
+}
+/**
+ * Enhanced Layout Resolver Options
+ */
+export interface EnhancedLayoutResolverOptions extends LayoutDiscoveryOptions {
+    enableCaching?: boolean;
+    cacheTTL?: number;
+    maxCacheSize?: number;
+    enableMetrics?: boolean;
+    enableDebugInfo?: boolean;
+}
+/**
+ * Simplified Enhanced Layout Resolver
+ * Handles: discovery → conditional filtering → composition → data loading → rendering
+ */
+export declare class EnhancedLayoutResolver implements IEnhancedLayoutResolver {
+    private readonly layoutDiscovery;
+    private readonly layoutMatcher;
+    private readonly layoutComposer;
+    private readonly layoutDataLoader;
+    private readonly cache;
+    private readonly cacheManager;
+    private readonly options;
+    constructor(options: EnhancedLayoutResolverOptions);
+    /**
+     * Resolve layout chain for a route
+     */
+    resolveLayouts(routePath: string, pageModule: PageModule, context: LayoutContext): Promise<ResolvedLayout>;
+    /**
+     * Resolve and render complete layout chain
+     */
+    resolveAndRender(routePath: string, pageModule: PageModule, context: LayoutContext): Promise<ResolvedLayout>;
+    private renderLayoutsToString;
+    getCachedResolution(cacheKey: string): ResolvedLayout | null;
+    invalidateCacheByFilePath(filePath: string): number;
+    clearCache(): void;
+    setCaching(enabled: boolean): void;
+    private generateCacheKey;
+    getResolverStats(): {
+        cacheSize: number;
+        cacheHitRate: number;
+        totalResolutions: number;
+        averageResolutionTime: number;
+        errorCount: number;
+        cacheStats: ReturnType<LayoutCacheManager['getStats']>;
+        discoveryStats: ReturnType<LayoutDiscovery['getCacheStats']>;
+    };
+    updateOptions(options: Partial<EnhancedLayoutResolverOptions>): void;
+    getOptions(): Required<EnhancedLayoutResolverOptions>;
+    getLayoutDiscovery(): LayoutDiscovery;
+    getLayoutMatcher(): LayoutMatcher;
+    getLayoutComposer(): LayoutComposer;
+    getLayoutDataLoader(): LayoutDataLoader;
+    getCacheManager(): LayoutCacheManager;
+    destroy(): void;
+}
+export declare function createEnhancedLayoutResolver(options: EnhancedLayoutResolverOptions): EnhancedLayoutResolver;
+export declare const EnhancedLayoutResolverUtils: {
+    createBasicConfig(baseDirectory: string, developmentMode?: boolean): EnhancedLayoutResolverOptions;
+    createProductionConfig(baseDirectory: string): EnhancedLayoutResolverOptions;
+};
+export {};

package/dist/src/core/layout/layout-cache-manager.d.ts

@@ -0,0 +1,66 @@
+import type { LayoutHandler, ResolvedLayout, LayoutData } from './layout-types.ts';
+export interface CacheEntry<T> {
+    value: T;
+    timestamp: number;
+    ttl: number;
+    accessCount: number;
+    lastAccessed: number;
+}
+export interface CacheStats {
+    hits: number;
+    misses: number;
+    evictions: number;
+    totalEntries: number;
+    memoryUsage: number;
+}
+export interface CacheConfig {
+    defaultTtl: number;
+    maxEntries: number;
+    cleanupInterval: number;
+    enableStats: boolean;
+    enableCompression?: boolean;
+    intelligentInvalidation?: boolean;
+    preloadThreshold?: number;
+}
+export declare class LayoutCacheManager {
+    private readonly config;
+    private readonly resolvedLayouts;
+    private readonly layoutHandlers;
+    private readonly layoutData;
+    private readonly dependencyGraph;
+    private readonly accessOrder;
+    private accessCounter;
+    private stats;
+    private cleanupTimer?;
+    constructor(config: CacheConfig);
+    setResolvedLayout(key: string, layout: ResolvedLayout, ttl?: number): void;
+    getResolvedLayout(key: string): ResolvedLayout | null;
+    setLayoutHandler(key: string, handler: LayoutHandler, ttl?: number): void;
+    getLayoutHandler(key: string): LayoutHandler | null;
+    setLayoutData(key: string, data: LayoutData, ttl?: number): void;
+    getLayoutData(key: string): LayoutData | null;
+    invalidateResolvedLayout(key: string): boolean;
+    invalidateLayoutHandler(key: string): boolean;
+    invalidateLayoutData(key: string): boolean;
+    invalidateByFilePath(filePath: string): number;
+    addDependency(key: string, dependsOn: string): void;
+    removeDependency(key: string, dependsOn: string): void;
+    invalidateByPattern(pattern: RegExp): number;
+    clear(): void;
+    getStats(): CacheStats;
+    getHitRate(): number;
+    private isExpired;
+    private invalidateDependents;
+    private normalizePath;
+    private isKeyAffectedByPath;
+    private updateAccessOrder;
+    private updateStats;
+    private estimateMemoryUsage;
+    private enforceMaxEntries;
+    private startCleanupTimer;
+    private cleanup;
+    private resetStats;
+    destroy(): void;
+}
+export declare const defaultCacheConfig: CacheConfig;
+export declare const layoutCache: LayoutCacheManager;

package/dist/src/core/layout/layout-composer.d.ts

@@ -0,0 +1,63 @@
+import { LayoutDiscovery } from './layout-discovery.ts';
+import type { LayoutHandler, LayoutConfig, LayoutDiscoveryOptions, PageModule } from './layout-types.ts';
+/**
+ * Layout composition control system that handles page-level layout customization.
+ * Provides support for skipLayouts, replaceLayout, onlyLayouts, and customLayout configurations.
+ *
+ * Requirements: 5.1, 5.2, 5.3, 5.4, 5.5
+ */
+export declare class LayoutComposer {
+    private readonly layoutDiscovery;
+    private readonly customLayoutCache;
+    private developmentMode;
+    constructor(options: LayoutDiscoveryOptions);
+    /**
+     * Resolves layouts for a route with page-level configuration applied
+     * Requirements: 5.1, 5.2, 5.3, 5.4, 5.5
+     */
+    resolveLayouts(routePath: string, pageModule: PageModule): Promise<LayoutHandler[]>;
+    /**
+     * Applies layout configuration to a layout chain
+     * Requirements: 5.2, 5.3, 5.4, 5.5
+     */
+    applyConfiguration(layouts: LayoutHandler[], config: LayoutConfig): Promise<LayoutHandler[]>;
+    /** Handles replaceLayout: returns only custom layout or empty array */
+    private handleReplaceLayout;
+    /** Checks if a layout matches a glob or exact path pattern */
+    private matchesLayoutPattern;
+    /** Removes layouts matching skipLayouts patterns */
+    private applySkipLayouts;
+    /** Keeps only layouts matching onlyLayouts patterns */
+    private applyOnlyLayouts;
+    /** Adds a custom layout to the layout chain */
+    private addCustomLayout;
+    /**
+     * Resolves a layout path to an absolute path, trying multiple resolution strategies.
+     */
+    private resolveLayoutPath;
+    /** Loads a custom layout from a file path */
+    private loadCustomLayout;
+    /** Validates layout configuration */
+    validateLayoutConfig(config: LayoutConfig): {
+        valid: boolean;
+        errors: string[];
+    };
+    /** Gets composition statistics for debugging */
+    getCompositionStats(): {
+        customLayoutCacheSize: number;
+        discoveryStats: {
+            layoutCount: number;
+            routeCacheCount: number;
+        };
+    };
+    /** Clears all caches */
+    clearCache(): void;
+    /** Clears custom layout cache */
+    clearCustomLayoutCache(): void;
+    /** Gets the underlying layout discovery instance */
+    getLayoutDiscovery(): LayoutDiscovery;
+    /** Sets development mode */
+    setDevelopmentMode(enabled: boolean): void;
+    /** Gets development mode status */
+    isDevelopmentMode(): boolean;
+}

package/dist/src/core/layout/layout-data-loader.d.ts

@@ -0,0 +1,146 @@
+import type { LayoutContext, LayoutData, LayoutHandler, LayoutErrorInfo } from './layout-types.ts';
+/**
+ * Layout data loading error with context information
+ */
+export declare class LayoutDataLoadingError extends Error {
+    readonly layoutPath: string;
+    readonly originalError?: Error;
+    constructor(message: string, layoutPath: string, originalError?: Error);
+}
+/**
+ * Result of a layout data loading operation
+ */
+export interface LayoutDataLoadingResult {
+    success: boolean;
+    data: LayoutData;
+    error?: LayoutDataLoadingError;
+    loadingTime: number;
+    layoutPath: string;
+}
+/**
+ * Options for layout data loading
+ */
+export interface LayoutDataLoadingOptions {
+    /**
+     * Maximum time to wait for data loading (in milliseconds)
+     */
+    timeout?: number;
+    /**
+     * Whether to enable parallel loading of multiple loaders
+     */
+    enableParallelLoading?: boolean;
+    /**
+     * Whether to continue loading other loaders if one fails
+     */
+    continueOnError?: boolean;
+    /**
+     * Development mode flag for enhanced error reporting
+     */
+    developmentMode?: boolean;
+    /**
+     * Maximum number of retry attempts for failed loaders
+     */
+    maxRetries?: number;
+    /**
+     * Delay between retry attempts (in milliseconds)
+     */
+    retryDelay?: number;
+}
+/**
+ * Layout data loader execution system
+ * Handles parallel data loading for multiple layout loaders in the chain
+ *
+ * Requirements: 2.1, 2.2, 2.3, 2.4, 2.5, 2.6
+ */
+export declare class LayoutDataLoader {
+    private readonly options;
+    constructor(options?: LayoutDataLoadingOptions);
+    /**
+     * Loads data for all layout handlers in the chain
+     * Requirements: 2.1, 2.2, 2.3, 2.4
+     */
+    loadLayoutData(layoutHandlers: LayoutHandler[], context: LayoutContext): Promise<LayoutDataLoadingResult[]>;
+    /**
+     * Loads data for multiple loaders in parallel with optimized batching
+     * Requirements: 2.2, 2.3, 2.4
+     */
+    private loadDataInParallel;
+    /**
+     * Loads data for multiple loaders sequentially
+     * Requirements: 2.2, 2.3, 2.4
+     */
+    private loadDataSequentially;
+    /**
+     * Loads data for a single layout handler with retry logic
+     * Requirements: 2.1, 2.2, 2.5, 2.6
+     */
+    private loadSingleLayoutData;
+    /**
+     * Executes a layout loader with timeout protection
+     * Requirements: 2.1, 2.5
+     */
+    private executeLoaderWithTimeout;
+    /**
+     * Creates enhanced layout context with parent data
+     * Requirements: 2.4, 2.6
+     */
+    createEnhancedContext(baseContext: LayoutContext, parentData: LayoutData[]): LayoutContext;
+    /**
+     * Processes layout data loading results and creates data array for components
+     * Requirements: 2.3, 2.4, 2.6
+     */
+    processLoadingResults(results: LayoutDataLoadingResult[], layoutHandlers: LayoutHandler[]): {
+        data: LayoutData[];
+        errors: LayoutErrorInfo[];
+    };
+    /**
+     * Creates fallback data for failed loaders
+     * Requirements: 2.5, 2.6
+     */
+    createFallbackData(layoutPath: string, error: LayoutDataLoadingError): LayoutData;
+    /**
+     * Validates layout data structure
+     * Requirements: 2.1, 2.3
+     */
+    validateLayoutData(data: unknown, layoutPath: string): LayoutData;
+    /**
+     * Utility method to create a delay
+     */
+    private delay;
+    /**
+     * Preload data for layouts that are likely to be needed soon
+     * Requirements: 2.1, 2.2
+     */
+    preloadLayoutData(layoutHandlers: LayoutHandler[], context: LayoutContext, priority?: 'high' | 'medium' | 'low'): Promise<void>;
+    /**
+     * Gets current loading options
+     */
+    getOptions(): Required<LayoutDataLoadingOptions>;
+    /**
+     * Updates loading options
+     */
+    updateOptions(options: Partial<LayoutDataLoadingOptions>): void;
+}
+/**
+ * Default layout data loader instance
+ */
+export declare const defaultLayoutDataLoader: LayoutDataLoader;
+/**
+ * Utility function to create a layout data loader with specific options
+ */
+export declare function createLayoutDataLoader(options?: LayoutDataLoadingOptions): LayoutDataLoader;
+/**
+ * Utility function to load data for a single layout
+ * Requirements: 2.1, 2.2
+ */
+export declare function loadSingleLayoutData(handler: LayoutHandler, context: LayoutContext, options?: LayoutDataLoadingOptions): Promise<LayoutDataLoadingResult>;
+/**
+ * Utility function to merge layout data from multiple sources
+ * Requirements: 2.4, 2.6
+ */
+export declare function mergeLayoutData(...dataSources: LayoutData[]): LayoutData;
+/**
+ * Utility function to extract parent data from context
+ * Requirements: 2.4, 2.6
+ */
+export declare function getParentLayoutData(context: LayoutContext): LayoutData[];

package/dist/src/core/layout/layout-discovery.d.ts

@@ -0,0 +1,51 @@
+import type { LayoutRoute, LayoutHandler, LayoutDiscoveryOptions, LayoutContext, LayoutData, LayoutErrorInfo } from './layout-types.ts';
+export type { LayoutDiscoveryOptions } from './layout-types.ts';
+/**
+ * Simplified Layout Discovery System
+ *
+ * Looks for _layout.tsx files in the path hierarchy from root to the current route.
+ *
+ * For route /admin/users/123:
+ * - Check src/layouts/_layout.tsx (root layout)
+ * - Check src/layouts/admin/_layout.tsx
+ * - Check src/layouts/admin/users/_layout.tsx
+ */
+export declare class LayoutDiscovery {
+    private readonly layoutCache;
+    private readonly routeCache;
+    private readonly baseDirectory;
+    private readonly filePattern;
+    private readonly developmentMode;
+    constructor(options: LayoutDiscoveryOptions);
+    /**
+     * Discovers all layout files for a given route path by walking up the path hierarchy
+     */
+    discoverLayouts(routePath: string): Promise<LayoutRoute[]>;
+    /**
+     * Builds a complete layout chain for a URL
+     */
+    buildLayoutChain(url: URL): Promise<LayoutHandler[]>;
+    /**
+     * Builds layout chain with data loading
+     */
+    buildLayoutChainWithData(url: URL, context: LayoutContext): Promise<{
+        handlers: LayoutHandler[];
+        data: LayoutData[];
+        errors: LayoutErrorInfo[];
+    }>;
+    /**
+     * Loads layout handler from file
+     */
+    private loadLayout;
+    /** Clears all caches */
+    clearCache(): void;
+    /** Clears cache for a specific layout file */
+    clearLayoutCache(filePath: string): void;
+    /** Gets cache statistics (for debugging) */
+    getCacheStats(): {
+        layoutCount: number;
+        routeCacheCount: number;
+    };
+    /** Gets the current discovery options */
+    getOptions(): LayoutDiscoveryOptions;
+}

package/dist/src/core/layout/layout-matcher.d.ts

@@ -0,0 +1,77 @@
+import type { LayoutRule, RouteInfo } from './layout-types.ts';
+/**
+ * Built-in layout rules for common scenarios
+ */
+export declare class BuiltInLayoutRules {
+    /**
+     * Rule to skip HTML layouts for API routes
+     * Requirements: 4.1
+     */
+    static readonly API_ROUTES_SKIP_LAYOUTS: LayoutRule;
+    /**
+     * Rule to apply mobile-specific layouts for mobile user agents
+     * Requirements: 4.2
+     */
+    static readonly MOBILE_LAYOUT_DETECTION: LayoutRule;
+    /**
+     * Rule to skip layouts based on specific headers
+     * Requirements: 4.3
+     */
+    static readonly HEADER_BASED_SKIP: LayoutRule;
+    /**
+     * Rule to apply admin layouts only for admin routes
+     * Requirements: 4.3
+     */
+    static readonly ADMIN_LAYOUT_RESTRICTION: LayoutRule;
+    static getAllRules(): LayoutRule[];
+}
+/**
+ * Layout matcher class that handles conditional layout rendering based on rules
+ * Requirements: 4.1, 4.2, 4.3, 4.4, 4.5
+ */
+export declare class LayoutMatcher {
+    private rules;
+    private readonly developmentMode;
+    constructor(options?: {
+        developmentMode?: boolean;
+    });
+    /**
+     * Add a new layout rule
+     * Requirements: 4.3
+     */
+    addRule(rule: LayoutRule): void;
+    /**
+     * Remove a layout rule
+     * Requirements: 4.3
+     */
+    removeRule(rule: LayoutRule): void;
+    /**
+     * Check if a layout should be applied based on all rules
+     * Requirements: 4.1, 4.2, 4.3, 4.4, 4.5
+     */
+    shouldApplyLayout(layoutPath: string, route: RouteInfo): boolean;
+    getRules(): LayoutRule[];
+    clearRules(): void;
+    private addBuiltInRules;
+    private sortRulesByPriority;
+    private getMatchingRules;
+    private resolveRuleConflicts;
+    private resolveEqualPriorityConflicts;
+    /**
+     * Create a custom rule
+     * Requirements: 4.3
+     */
+    static createCustomRule(matcher: (route: RouteInfo) => boolean, apply: boolean, priority?: number): LayoutRule;
+    static createPathRule(pathPattern: string | RegExp, apply: boolean, priority?: number): LayoutRule;
+    static createHeaderRule(headerName: string, headerValue: string | RegExp, apply: boolean, priority?: number): LayoutRule;
+    static createMethodRule(methods: string | string[], apply: boolean, priority?: number): LayoutRule;
+    getDebugInfo(layoutPath: string, route: RouteInfo): {
+        totalRules: number;
+        matchingRules: Array<{
+            priority: number;
+            apply: boolean;
+        }>;
+        finalDecision: boolean;
+        conflictResolution?: string;
+    };
+}

package/dist/src/core/layout/layout-types.d.ts

@@ -0,0 +1,94 @@
+/**
+ * Shared layout type definitions for the core/layout module.
+ *
+ * These are pure TypeScript interfaces with NO zod dependency,
+ * intentionally kept separate from schemas/layout.ts to avoid
+ * importing zod at cold start time.
+ */
+export type ComponentType<P = any> = ((props: P) => any) | (new (props: P) => any);
+export interface LayoutContext {
+    request: Request;
+    params: Record<string, string>;
+    query: URLSearchParams;
+    state: Map<string, unknown>;
+    middlewareContext?: unknown;
+}
+export type LayoutData = Record<string, unknown>;
+export type LayoutLoader = (ctx: LayoutContext) => Promise<LayoutData>;
+export interface LayoutProps {
+    children: import('preact').ComponentChildren;
+    data: LayoutData;
+    frontmatter?: Record<string, unknown>;
+    route: {
+        path: string;
+        params: Record<string, string>;
+        query: URLSearchParams;
+    };
+}
+export interface LayoutHandler {
+    component: ComponentType<LayoutProps>;
+    loader?: LayoutLoader;
+    path: string;
+    priority: number;
+}
+export interface LayoutRoute {
+    pattern: URLPattern;
+    layoutPath: string;
+    priority: number;
+    type: 'root' | 'nested';
+    depth: number;
+}
+export interface LayoutDiscoveryOptions {
+    baseDirectory: string;
+    filePattern?: string;
+    excludeDirectories?: string[];
+    enableWatching?: boolean;
+    developmentMode?: boolean;
+}
+export interface LayoutConfig {
+    skipLayouts?: string[];
+    replaceLayout?: boolean;
+    onlyLayouts?: string[];
+    customLayout?: string;
+}
+export interface RouteInfo {
+    path: string;
+    params: Record<string, string>;
+    method: string;
+    headers: Headers;
+}
+export interface LayoutRule {
+    matches: (route: RouteInfo, layoutPath?: string) => boolean;
+    apply: boolean;
+    priority: number;
+}
+export interface LayoutErrorInfo {
+    layoutPath: string;
+    errorType: 'component' | 'loader' | 'rendering' | 'island';
+    timestamp: number;
+    componentStack?: string;
+    errorBoundary?: string;
+}
+export interface ResolvedLayout {
+    handlers: LayoutHandler[];
+    dataLoaders: LayoutLoader[];
+    errorBoundaries: unknown[];
+    streamingComponents: unknown[];
+    metadata: {
+        totalLayouts: number;
+        resolutionTime: number;
+        cacheHit: boolean;
+    };
+}
+export interface LayoutCache {
+    resolved: Map<string, ResolvedLayout>;
+    handlers: Map<string, LayoutHandler>;
+    data: Map<string, LayoutData>;
+    ttl: Map<string, number>;
+}
+export interface PageModule {
+    default: ComponentType<Record<string, unknown>>;
+    layoutConfig?: LayoutConfig;
+    loader?: LayoutLoader;
+    frontmatter?: Record<string, unknown>;
+}

package/dist/src/core/modules/framework-module-resolver.d.ts

@@ -0,0 +1,85 @@
+/**
+ * Framework-aware module resolver for handling framework-specific path transformations
+ * and MIME type resolution during hydration and module serving.
+ */
+export interface ModuleResolutionConfig {
+    framework: string;
+    baseUrl: string;
+    extensions: string[];
+    transformPath: (path: string) => string;
+    mimeType: string;
+}
+export interface ResolvedModule {
+    originalPath: string;
+    resolvedPath: string;
+    framework: string;
+    shouldTransform: boolean;
+    mimeType: string;
+    url: string;
+}
+export interface FrameworkModuleConfig {
+    extensions: string[];
+    hydrationExtension: string;
+    mimeType: string;
+    transformPath: (path: string, mode: 'development' | 'production') => string;
+}
+export declare class FrameworkModuleResolver {
+    private mode;
+    private baseUrl;
+    constructor(mode?: 'development' | 'production', baseUrl?: string);
+    /**
+     * Resolve a module path for a specific framework
+     */
+    resolveModule(originalPath: string, framework: string, options?: {
+        forHydration?: boolean;
+        baseUrl?: string;
+    }): ResolvedModule;
+    /**
+     * Check if a path needs transformation for the given framework
+     */
+    needsTransformation(path: string, framework: string): boolean;
+    /**
+     * Get the appropriate MIME type for a file path
+     */
+    getMimeType(path: string): string;
+    /**
+     * Generate a module URL for the given path
+     */
+    generateModuleUrl(path: string, baseUrl?: string): string;
+    /**
+     * Get supported frameworks
+     */
+    getSupportedFrameworks(): string[];
+    /**
+     * Get framework configuration
+     */
+    getFrameworkConfig(framework: string): FrameworkModuleConfig | undefined;
+    /**
+     * Check if a framework is supported
+     */
+    isFrameworkSupported(framework: string): boolean;
+    /**
+     * Get file extension from path
+     */
+    private getFileExtension;
+    /**
+     * Set the resolver mode (development/production)
+     */
+    setMode(mode: 'development' | 'production'): void;
+    /**
+     * Get current mode
+     */
+    getMode(): 'development' | 'production';
+    /**
+     * Set base URL for module resolution
+     */
+    setBaseUrl(baseUrl: string): void;
+    /**
+     * Get current base URL
+     */
+    getBaseUrl(): string;
+}
+/**
+ * Default instance for common usage
+ */
+export declare const frameworkModuleResolver: FrameworkModuleResolver;