@useavalon/avalon 0.1.23 → 0.1.24

package/dist/mod.d.ts

@@ -0,0 +1,50 @@
+export { avalon, getResolvedConfig, getPagesDir, getLayoutsDir, getNitroConfig, isNitroEnabled, } from './src/vite-plugin/plugin.ts';
+export type { AvalonPluginConfig, IntegrationName, ResolvedAvalonConfig, MDXConfig, ResolvedMDXConfig, AvalonNitroConfig, CacheOptions, RouteRule, NitroConfigOutput, AvalonRuntimeConfig, } from './src/vite-plugin/types.ts';
+export { createNitroIntegration, createNitroCoordinationPlugin, createVirtualModulesPlugin, getViteDevServer, getAvalonConfig, isDevelopmentMode, VIRTUAL_MODULE_IDS, RESOLVED_VIRTUAL_IDS, } from './src/vite-plugin/nitro-integration.ts';
+export type { NitroIntegrationResult, NitroCoordinationPluginOptions } from './src/vite-plugin/nitro-integration.ts';
+export { renderToHtml } from './src/render/ssr.ts';
+export { default as Island, renderIsland, type IslandProps } from './src/islands/island.tsx';
+export { addSvelteSSRCSS, getSvelteSSRCSS, getSvelteSSRCSSForHead, getSvelteSSRCSSStats, getSvelteComponentCSS, clearSvelteComponentCSS, generateComponentScopeId, } from './src/islands/css-utils.ts';
+export { detectFramework, detectFrameworkFromSrc, resolveIslandPath } from './src/islands/framework-detection.ts';
+export { analyzeComponentFile, renderComponentSSROnly } from './src/islands/component-analysis.ts';
+export type { Framework, RenderParams, SvelteSSRCSSEntry } from './src/islands/types.ts';
+export { clearCache, clearIslandCache, invalidateCacheForPath, invalidateCacheForFile, getCacheStats, logCacheStats, configureCache, getCacheConfig, } from './src/islands/render-cache.ts';
+export type { CacheConfig as IslandCacheConfig, CacheStats as IslandCacheStats } from './src/islands/render-cache.ts';
+export { discoverIslandDirectories, discoverIslandsInDirectory, discoverAllIslands, isIslandsDirectory, getDefaultIslandsPath, hasDefaultIslandsDirectory, getQualifiedIslandName, parseQualifiedIslandName, IslandRegistry, createIslandRegistry, IslandResolver, createIslandResolver, IslandValidator, createIslandValidator, validateAllIslands, formatValidationError, formatValidationWarning, formatCircularDependency, formatValidationResult, IslandWatcher, createIslandWatcher, ISLAND_FILE_EXTENSIONS, DEFAULT_DISCOVERY_CONFIG, isSupportedIslandExtension, } from './src/islands/discovery/index.ts';
+export type { IslandDirectory, DiscoveredIsland, IslandCollision, IslandChangeEvent, IslandFileExtension, IslandDiscoveryConfig, ResolutionResult, ImportPathOptions, ValidationResult, ValidationError, ValidationWarning, CircularDependency, IslandChangeCallback, IslandWatcherOptions, } from './src/islands/discovery/index.ts';
+export { loadIntegration, detectAndLoadIntegration, preloadIntegrations, detectFrameworksFromPageContent, DEFAULT_PRELOAD_FRAMEWORKS, } from './src/islands/integration-loader.ts';
+export type { PreloadIntegrationsOptions } from './src/islands/integration-loader.ts';
+export { registry as integrationRegistry } from './src/core/integrations/registry.ts';
+export type { Integration, RenderParams as IntegrationRenderParams, RenderResult, IntegrationConfig, } from '@useavalon/core';
+export { generateIslandManifest, loadIslandManifest, getIslandBundlePath } from './src/build/island-manifest.ts';
+export type { IslandManifest, IslandEntry, ExtendedIslandManifest, ExtendedIslandEntry, } from './src/build/island-manifest.ts';
+export { mdxIslandTransform } from './src/build/mdx-island-transform.ts';
+export type { MDXIslandTransformOptions } from './src/build/mdx-island-transform.ts';
+export { pageIslandTransform } from './src/build/page-island-transform.ts';
+export type { PageIslandTransformOptions } from './src/build/page-island-transform.ts';
+export type { IslandDirective } from './src/types/island-prop.d.ts';
+export { asIsland } from './src/types/as-island.ts';
+export { generateIslandTypes, watchAndGenerateTypes } from './src/build/island-types-generator.ts';
+export type { IslandTypeGeneratorOptions, TypeGenerationResult } from './src/build/island-types-generator.ts';
+export declare function build(_options?: Record<string, unknown>): Promise<void>;
+export { discoverScopedMiddleware, executeScopedMiddleware, clearMiddlewareCache, invalidateMiddleware, getMatchingMiddleware, clearDiscoveryCache, hasContextValue, getContextValue, setContextValue, getMiddlewareCacheSize, } from './src/middleware/index.ts';
+export type { MiddlewareHandler, MiddlewareFileExport, MiddlewareRoute, MiddlewareDiscoveryOptions, MiddlewareExecutorOptions, } from './src/middleware/types.ts';
+export * from './src/layout-system.ts';
+export type { RenderOptions, MetaTag, ScriptConfig } from './src/schemas/core.ts';
+export type { ApiRoute, ApiMethod } from './src/schemas/api.ts';
+export type { MiddlewareContext } from './src/nitro/middleware-adapter.ts';
+export type { LayoutDataLoadingResult, LayoutDataLoadingOptions } from './src/core/layout/layout-data-loader.ts';
+export type { EnhancedLayoutResolverOptions } from './src/core/layout/enhanced-layout-resolver.ts';
+export type { CacheEntry, CacheStats, CacheConfig } from './src/core/layout/layout-cache-manager.ts';
+export type { LayoutProps, LayoutContext, LayoutData, LayoutRoute, LayoutHandler, LayoutDiscoveryOptions, LayoutConfig, RouteInfo, LayoutRule, LayoutLoader, ResolvedLayout, LayoutCache, LayoutErrorInfo } from './src/core/layout/layout-types.ts';
+export type { EnhancedLayoutContext, IslandState, PersistentIslandProps, PersistentIslandContext, IslandStateSaver, IslandStateLoader, IslandStateClearer, LayoutErrorBoundaryProps, ErrorRecoveryStrategy, LayoutErrorHandler, LayoutRetryFunction, LayoutFallbackRenderer, StreamingLayoutProps, StreamingComponent, StreamingReadyCheck, LayoutMatcherFunction, } from './src/schemas/layout.ts';
+export { IslandPersistence, defaultIslandPersistence } from './src/core/islands/island-persistence.ts';
+export { IslandStateSerializer } from './src/core/islands/island-state-serializer.ts';
+export { createPersistentIslandContext, usePersistentIslandContext, PersistentIslandProvider, } from './src/core/islands/persistent-island-context.tsx';
+export { PersistentIsland } from './src/components/PersistentIsland.tsx';
+export { usePersistentState } from './src/core/islands/use-persistent-state.ts';
+export { LayoutErrorBoundary } from './src/components/LayoutErrorBoundary.tsx';
+export { LayoutDataErrorBoundary } from './src/components/LayoutDataErrorBoundary.tsx';
+export { IslandErrorBoundary, withIslandErrorBoundary } from './src/components/IslandErrorBoundary.tsx';
+export { StreamingErrorBoundary, withStreamingErrorBoundary } from './src/components/StreamingErrorBoundary.tsx';
+export type { ILayoutDiscovery, ILayoutMatcher, ILayoutComposer, IIslandPersistence, ILayoutErrorRecovery, ILayoutStreaming, IEnhancedLayoutResolver, ILayoutComponent, IPersistentIslandComponent, ILayoutErrorBoundaryComponent, IStreamingLayoutComponent, LayoutModule, PageModule, LayoutResolutionContext, LayoutPerformanceMetrics, LayoutDebugInfo, LayoutEventType, LayoutEventData, LayoutEventHandler, ILayoutEventEmitter, } from './src/types/layout.ts';

package/dist/src/build/integration-bundler-plugin.d.ts

@@ -0,0 +1,25 @@
+import type { Plugin } from 'vite';
+export interface IntegrationBundlerOptions {
+    /** Integrations to include in the build */
+    integrations: string[];
+    /** Whether to bundle for SSR */
+    ssr?: boolean;
+}
+/**
+ * Vite plugin to bundle integration packages
+ * Ensures integration server and client code is properly bundled
+ */
+export declare function integrationBundlerPlugin(options: IntegrationBundlerOptions): Plugin;
+/**
+ * Get external dependencies for integration bundling
+ * These should not be bundled but loaded from node_modules
+ */
+export declare function getIntegrationExternals(framework: string, ssr: boolean): string[];
+/**
+ * Configure optimization for integration dependencies
+ */
+export declare function getIntegrationOptimizeDeps(integrations: string[]): string[];
+/**
+ * Get SSR noExternal packages for integrations
+ */
+export declare function getIntegrationSSRNoExternal(integrations: string[]): string[];

package/dist/src/build/integration-config.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Integration configuration for build system
+ * Defines how each integration should be bundled and optimized
+ */
+export interface IntegrationBuildConfig {
+    /** Framework name */
+    name: string;
+    /** File extensions this integration handles */
+    extensions: string[];
+    /** NPM packages that should be optimized for this integration */
+    optimizeDeps: string[];
+    /** NPM packages that should be external in SSR builds */
+    ssrExternal: string[];
+    /** NPM packages that should NOT be external in SSR builds */
+    ssrNoExternal: string[];
+    /** Whether this integration requires a Vite plugin */
+    requiresPlugin: boolean;
+    /** Plugin package name (if requiresPlugin is true) */
+    pluginPackage?: string;
+}
+/**
+ * Build configuration for all supported integrations
+ */
+export declare const INTEGRATION_BUILD_CONFIGS: Record<string, IntegrationBuildConfig>;
+/**
+ * Get build configuration for a specific integration
+ */
+export declare function getIntegrationBuildConfig(framework: string): IntegrationBuildConfig;
+/**
+ * Get all optimize deps for given integrations
+ */
+export declare function getOptimizeDepsForIntegrations(integrations: string[]): string[];
+/**
+ * Get SSR noExternal packages for given integrations
+ */
+export declare function getSSRNoExternalForIntegrations(integrations: string[]): string[];
+/**
+ * Check if an integration requires a Vite plugin
+ */
+export declare function integrationRequiresPlugin(framework: string): boolean;
+/**
+ * Get plugin package name for an integration
+ */
+export declare function getIntegrationPluginPackage(framework: string): string;

package/dist/src/build/integration-detection-plugin.d.ts

@@ -0,0 +1,20 @@
+import type { Plugin } from 'vite';
+export interface IntegrationDetectionResult {
+    preact: boolean;
+    vue: boolean;
+    solid: boolean;
+    svelte: boolean;
+}
+/**
+ * Vite plugin to detect which framework integrations are used in the project
+ * This enables tree-shaking of unused integrations
+ */
+export declare function integrationDetectionPlugin(): Plugin;
+/**
+ * Detect which framework integrations are actually used in the project
+ */
+export declare function detectUsedIntegrations(): Promise<IntegrationDetectionResult>;
+/**
+ * Get list of integration packages that should be included in the build
+ */
+export declare function getRequiredIntegrations(detected: IntegrationDetectionResult): string[];

package/dist/src/build/integration-resolver-plugin.d.ts

@@ -0,0 +1,10 @@
+import type { Plugin } from 'vite';
+/**
+ * Vite plugin to resolve integration package imports
+ * Handles both @useavalon/integration-* imports and relative imports within integrations
+ */
+export declare function integrationResolverPlugin(): Plugin;
+/**
+ * Create alias configuration for integration imports
+ */
+export declare function createIntegrationAliases(): Record<string, string>;

package/dist/src/build/island-manifest.d.ts

@@ -0,0 +1,57 @@
+import { type IslandDirectory, type IslandCollision } from '../islands/discovery/index.ts';
+export interface IslandManifest {
+    islands: Record<string, IslandEntry>;
+    version: string;
+    buildTime: number;
+}
+/**
+ * Extended island manifest with nested islands support
+ */
+export interface ExtendedIslandManifest extends IslandManifest {
+    /** All discovered island directories */
+    directories: IslandDirectory[];
+    /** Detected naming collisions */
+    collisions: IslandCollision[];
+}
+export interface IslandEntry {
+    /** Original source path */
+    src: string;
+    /** Built bundle path */
+    bundle: string;
+    /** Bundle hash for cache busting */
+    hash: string;
+    /** Framework type (preact, solid, vue, svelte, vanilla, lit, react) */
+    framework: 'preact' | 'solid' | 'vue' | 'svelte' | 'vanilla' | 'lit' | 'react' | 'unknown';
+    /** Import dependencies */
+    deps: string[];
+}
+/**
+ * Extended island entry with namespace support
+ */
+export interface ExtendedIslandEntry extends IslandEntry {
+    /** Namespace for the island (empty string for default directory) */
+    namespace: string;
+    /** Qualified name including namespace (e.g., "modules/auth/Counter") */
+    qualifiedName: string;
+    /** Original directory path */
+    sourceDirectory: string;
+}
+/**
+ * Generate island manifest during build using the nested islands discovery service.
+ * Discovers all islands across all directories and generates manifest entries
+ * with namespace and qualified name support.
+ */
+export declare function generateIslandManifest(): Promise<ExtendedIslandManifest>;
+/**
+ * Load island manifest (for production)
+ */
+export declare function loadIslandManifest(): Promise<ExtendedIslandManifest | null>;
+/**
+ * Get bundle path for an island (development vs production)
+ * Supports both simple names and qualified names (namespace/name)
+ */
+export declare function getIslandBundlePath(src: string, manifest?: ExtendedIslandManifest | IslandManifest | null): string;
+/**
+ * Get island entry by qualified name or simple name
+ */
+export declare function getIslandEntry(nameOrQualified: string, manifest: ExtendedIslandManifest | IslandManifest): ExtendedIslandEntry | IslandEntry | null;

package/dist/src/build/island-types-generator.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Island Types Generator
+ *
+ * Generates TypeScript declaration files (.d.ts) for discovered islands.
+ * Provides type information including namespace and qualified names for
+ * better IDE support and type safety when referencing islands.
+ */
+/**
+ * Options for type generation
+ */
+export interface IslandTypeGeneratorOptions {
+    /** Output directory for generated types (default: "src/types") */
+    outputDir?: string;
+    /** Whether to generate a single file or per-directory files (default: "single") */
+    mode?: "single" | "per-directory";
+    /** Module name for the generated types (default: "avalon-islands") */
+    moduleName?: string;
+    /** Whether to include JSDoc comments (default: true) */
+    includeJsDoc?: boolean;
+}
+/**
+ * Result of type generation
+ */
+export interface TypeGenerationResult {
+    /** Whether generation was successful */
+    success: boolean;
+    /** Generated file paths */
+    files: string[];
+    /** Number of islands typed */
+    islandCount: number;
+    /** Any errors that occurred */
+    errors: string[];
+}
+/**
+ * Generate TypeScript declaration files for all discovered islands.
+ *
+ * @param projectRoot - The root directory of the project
+ * @param options - Options for type generation
+ * @returns Result of the type generation
+ */
+export declare function generateIslandTypes(projectRoot: string, options?: IslandTypeGeneratorOptions): Promise<TypeGenerationResult>;
+/**
+ * Watch for island changes and regenerate types.
+ *
+ * @param projectRoot - The root directory of the project
+ * @param options - Options for type generation
+ * @returns Cleanup function to stop watching
+ */
+export declare function watchAndGenerateTypes(projectRoot: string, options?: IslandTypeGeneratorOptions): Promise<() => void>;

package/dist/src/build/mdx-island-transform.d.ts

@@ -0,0 +1,23 @@
+/**
+ * MDX Island Transform Plugin
+ *
+ * Transforms island component usage in MDX files into renderIsland() calls.
+ *
+ * Supports two patterns:
+ * 1. Imports from islands/ directories (legacy pattern)
+ * 2. Components used with the `island` prop (preferred pattern)
+ *
+ * Problem: MDX files import island components directly and render them as raw JSX.
+ * After MDX compilation, these become jsxDEV(ComponentName, ...) calls. Preact's
+ * renderToString doesn't support async components, so we can't use async wrappers.
+ *
+ * Solution: Replaces the compiled JSX calls (_jsxDEV(Component, { island: ... }))
+ * with await expressions that call renderIsland() directly. This allows proper
+ * async SSR rendering of islands in MDX files.
+ */
+import type { Plugin } from 'vite';
+export interface MDXIslandTransformOptions {
+    islandPathPatterns?: RegExp[];
+    verbose?: boolean;
+}
+export declare function mdxIslandTransform(options?: MDXIslandTransformOptions): Plugin;

package/dist/src/build/mdx-plugin.d.ts

@@ -0,0 +1,36 @@
+import type { Plugin } from 'vite';
+import type { Pluggable } from 'unified';
+export interface MDXPluginOptions {
+    remarkPlugins?: Pluggable[];
+    rehypePlugins?: Pluggable[];
+    development?: boolean;
+    jsxImportSource?: string;
+    /** Enable syntax highlighting via rehype-highlight (default: true) */
+    syntaxHighlighting?: boolean;
+}
+/**
+ * Creates and configures the MDX Vite plugin
+ *
+ * This function sets up the MDX plugin with:
+ * - Frontmatter processing (remark-frontmatter, remark-mdx-frontmatter)
+ * - GitHub Flavored Markdown support (remark-gfm)
+ * - Syntax highlighting (rehype-highlight) - enabled by default
+ * - Custom remark/rehype plugins
+ * - JSX runtime configuration
+ *
+ * @param options - MDX plugin configuration options
+ * @returns Array of Vite plugins (empty if MDX dependencies are not available)
+ *
+ * @example
+ * ```ts
+ * // Basic usage with defaults
+ * const plugins = await createMDXPlugin();
+ *
+ * // With React JSX runtime
+ * const plugins = await createMDXPlugin({ jsxImportSource: 'react' });
+ *
+ * // Disable syntax highlighting
+ * const plugins = await createMDXPlugin({ syntaxHighlighting: false });
+ * ```
+ */
+export declare function createMDXPlugin(options?: MDXPluginOptions): Promise<Plugin[]>;

package/dist/src/build/page-island-transform.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Page Island Transform Plugin
+ *
+ * Transforms components with an `island` prop in TSX/JSX page files so that developers
+ * can use any component as an island by simply adding the `island` prop.
+ *
+ * Before (manual):
+ *   import { renderIsland } from '@useavalon/avalon';
+ *   {await renderIsland({ src: '/src/components/Counter.tsx', condition: 'on:interaction', framework: 'preact' })}
+ *
+ * After (auto-wrapped):
+ *   import Counter from '../components/Counter.tsx';
+ *   <Counter island={{ condition: 'on:interaction' }} someProp={42} />
+ *
+ * How it works:
+ *   The plugin rewrites each `<Component island={opts} ...props />` JSX usage
+ *   into an `{await renderIsland({...})}` expression inline in the JSX.
+ *   Any component can be an island - no special directory required.
+ *
+ *   Preact's renderToString does NOT support async child components in the JSX
+ *   tree, so we cannot use async wrapper functions. Instead we directly replace
+ *   the JSX element with an await expression.
+ *
+ * Only applies to files inside the configured pages or layouts directories.
+ */
+import type { Plugin } from 'vite';
+export interface PageIslandTransformOptions {
+    /** Directory containing page files (default: src/pages/) */
+    pagesDir?: string;
+    /** Directory containing layout files (default: src/layouts/) */
+    layoutsDir?: string;
+    /** Modules configuration for modular architecture */
+    modules?: {
+        dir: string;
+        pagesDirName: string;
+        layoutsDirName: string;
+    } | null;
+    /** Whether to enable verbose logging */
+    verbose?: boolean;
+}
+export declare function pageIslandTransform(options?: PageIslandTransformOptions): Plugin;

package/dist/src/build/prop-extractors/index.d.ts

@@ -0,0 +1,8 @@
+export { type PropExtractionResult, FALLBACK_PROPS, extractVueProps } from "./vue.ts";
+export { extractSvelteProps } from "./svelte.ts";
+export { extractLitProps } from "./lit.ts";
+export { extractSolidProps } from "./solid.ts";
+export { extractQwikProps } from "./qwik.ts";
+import type { PropExtractionResult } from "./vue.ts";
+/** Maps framework name to its prop extractor function */
+export declare const EXTRACTOR_MAP: Record<string, (source: string) => PropExtractionResult>;

package/dist/src/build/prop-extractors/lit.d.ts

@@ -0,0 +1,11 @@
+import { type PropExtractionResult } from "./vue.ts";
+/**
+ * Extract props from a Lit element source string.
+ *
+ * Parses `static properties = { ... }` blocks and maps Lit type
+ * constructors to TypeScript types. Properties with `state: true`
+ * are excluded (internal state, not public props).
+ *
+ * Never throws — returns fallback on any failure.
+ */
+export declare function extractLitProps(source: string): PropExtractionResult;

package/dist/src/build/prop-extractors/qwik.d.ts

@@ -0,0 +1,9 @@
+import type { PropExtractionResult } from "./vue.ts";
+/**
+ * Extract props type from a Qwik component file.
+ * Qwik components use component$(() => ...) — props are typed via the
+ * generic parameter or a Props interface. For now we fall back to
+ * Record<string, unknown> since Qwik's JSX types aren't Preact-compatible
+ * and the sidecar just needs to expose the island prop.
+ */
+export declare function extractQwikProps(_source: string): PropExtractionResult;

package/dist/src/build/prop-extractors/solid.d.ts

@@ -0,0 +1,12 @@
+import { type PropExtractionResult } from "./vue.ts";
+/**
+ * Extract props from a Solid component source string.
+ *
+ * Supports two patterns:
+ *   1. `export default function Name(props: { ... })` — named function export
+ *   2. `export default (props: { ... }) =>` — arrow function export
+ *
+ * Uses brace-counting to handle nested types in the props parameter.
+ * Never throws — returns fallback on any failure.
+ */
+export declare function extractSolidProps(source: string): PropExtractionResult;

package/dist/src/build/prop-extractors/svelte.d.ts

@@ -0,0 +1,13 @@
+import { type PropExtractionResult } from "./vue.ts";
+/**
+ * Extract props from a Svelte component source string.
+ *
+ * Supports three patterns:
+ *   1. `let { ... }: { ... } = $props()` — inline type literal
+ *   2. `let { ... }: TypeName = $props()` or `let name: TypeName = $props()`
+ *      — named type resolved from an interface/type declaration in the script block
+ *   3. `export let name: type` — Svelte 4 style, collected into a type literal
+ *
+ * Never throws — returns fallback on any failure.
+ */
+export declare function extractSvelteProps(source: string): PropExtractionResult;

package/dist/src/build/prop-extractors/vue.d.ts

@@ -0,0 +1,19 @@
+/** Result of prop extraction */
+export interface PropExtractionResult {
+    /** The TypeScript type literal for props, e.g. "{ count?: number }" */
+    propsType: string;
+    /** Whether extraction succeeded or fell back */
+    fallback: boolean;
+}
+/** Fallback props type used when extraction fails or no props are found */
+export declare const FALLBACK_PROPS = "Record<string, unknown>";
+/**
+ * Extract props from a Vue SFC source string.
+ *
+ * Looks for `defineProps<{...}>()` inside a `<script setup>` or
+ * `<script setup lang="ts">` block. Uses brace-counting to handle
+ * nested types within the angle brackets.
+ *
+ * Never throws — returns fallback on any failure.
+ */
+export declare function extractVueProps(source: string): PropExtractionResult;

package/dist/src/build/sidecar-file-manager.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Compute the sidecar declaration file path for a given island file path.
+ *
+ * For simple extensions like `.vue`, the sidecar is `Name.d.vue.ts`.
+ * For compound extensions like `.lit.ts`, the sidecar is `Name.d.lit.ts`.
+ * For `.solid.tsx`, the sidecar is `Name.d.solid.tsx.ts`.
+ */
+export declare function getSidecarPath(islandFilePath: string): string;
+/**
+ * Check if a sidecar file is up-to-date by comparing mtimes.
+ * Returns `true` if the sidecar exists and is newer than the source file.
+ */
+export declare function isSidecarFresh(sourcePath: string, sidecarPath: string): Promise<boolean>;
+/**
+ * Write sidecar content only if it differs from the existing file.
+ * Returns `true` if a write was performed, `false` if content was already up-to-date.
+ */
+export declare function writeSidecarIfChanged(sidecarPath: string, content: string): Promise<boolean>;
+/**
+ * Delete a sidecar file if it exists.
+ * Returns `true` if a file was deleted, `false` if it didn't exist.
+ */
+export declare function deleteSidecar(sidecarPath: string): Promise<boolean>;

package/dist/src/build/sidecar-renderer.d.ts

@@ -0,0 +1,22 @@
+/** Header comment placed at the top of every generated sidecar file. */
+export declare const SIDECAR_HEADER = "// Auto-generated by avalon \u2014 do not edit";
+/**
+ * Render the full content of a sidecar declaration file.
+ *
+ * Pure function: takes a props type string (e.g. `"{ count: number }"` or
+ * `"Record<string, unknown>"`) and returns the complete file content.
+ *
+ * The `island` prop is always included so the component can be used with
+ * `<Component island={{ condition: 'on:interaction' }} />` in page files.
+ * The Vite page-island-transform strips it at build time.
+ *
+ * The output follows this exact template:
+ * ```
+ * // Auto-generated by avalon — do not edit
+ * import type { ComponentType } from 'preact';
+ * import type { IslandDirective } from '@useavalon/avalon';
+ * declare const component: ComponentType<PROPS & { island?: IslandDirective }>;
+ * export default component;
+ * ```
+ */
+export declare function renderSidecarContent(propsType: string): string;

package/dist/src/client/adapters/index.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Framework HMR Adapters
+ *
+ * HMR adapters have been moved to their respective integration packages:
+ * - @useavalon/react/client/hmr
+ * - @useavalon/preact/client/hmr
+ * - @useavalon/vue/client/hmr
+ * - @useavalon/svelte/client/hmr
+ * - @useavalon/solid/client/hmr
+ * - @useavalon/lit/client/hmr
+ * - @useavalon/qwik/client/hmr
+ *
+ * This barrel re-exports from the base framework adapter for backward compatibility.
+ */
+export { BaseFrameworkAdapter, AdapterRegistry, type FrameworkHMRAdapter, type StateSnapshot, } from '../framework-adapter.ts';

package/dist/src/client/components.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Client-safe component exports for use in island components.
+ *
+ * Import from '@useavalon/avalon/client' instead of '@useavalon/avalon' when
+ * you need framework components inside islands. The main entry point
+ * re-exports server-only code (nitro, h3, vite plugins) that can't
+ * be bundled for the browser.
+ */
+export { PersistentIsland } from '../components/PersistentIsland.tsx';
+export { usePersistentIslandContext, PersistentIslandProvider, createPersistentIslandContext, } from '../core/islands/persistent-island-context.tsx';
+export { usePersistentState } from '../core/islands/use-persistent-state.ts';
+export { IslandPersistence, defaultIslandPersistence } from '../core/islands/island-persistence.ts';
+export { IslandStateSerializer } from '../core/islands/island-state-serializer.ts';
+export { IslandErrorBoundary, withIslandErrorBoundary } from '../components/IslandErrorBoundary.tsx';
+export { LayoutErrorBoundary } from '../components/LayoutErrorBoundary.tsx';
+export { LayoutDataErrorBoundary } from '../components/LayoutDataErrorBoundary.tsx';
+export { StreamingErrorBoundary, withStreamingErrorBoundary } from '../components/StreamingErrorBoundary.tsx';
+export { StreamingLayout, StreamingSuspense, withStreaming, useStreamingState } from '../components/StreamingLayout.tsx';
+export { Image } from '../components/Image.tsx';
+export type { ImageProps } from '../components/Image.tsx';
+export type { IslandState } from '../schemas/layout.ts';

package/dist/src/client/css-hmr-handler.d.ts

@@ -0,0 +1,94 @@
+/**
+ * CSS HMR Handler
+ *
+ * Handles Hot Module Replacement for CSS files including:
+ * - Global CSS files
+ * - CSS modules
+ * - Component-scoped styles (Svelte, Vue)
+ */
+import type { Update } from './hmr-coordinator.ts';
+/**
+ * CSS update types
+ */
+export type CSSUpdateType = 'global' | 'module' | 'scoped';
+/**
+ * CSS update information
+ */
+export interface CSSUpdateInfo {
+    type: CSSUpdateType;
+    path: string;
+    timestamp: number;
+    affectedComponents?: string[];
+}
+/**
+ * CSS HMR Handler class
+ * Manages CSS hot updates without page reload
+ */
+export declare class CSSHMRHandler {
+    private cssModuleMap;
+    private styleElementMap;
+    /**
+     * Handle CSS update from Vite HMR
+     */
+    handleCSSUpdate(update: Update): void;
+    /**
+     * Classify the type of CSS update
+     */
+    private classifyCSSUpdate;
+    /**
+     * Handle global CSS file update
+     * Injects updated styles without page reload
+     */
+    private handleGlobalCSSUpdate;
+    /**
+     * Handle CSS module update
+     * Re-renders components using the updated CSS module
+     */
+    private handleCSSModuleUpdate;
+    /**
+     * Handle scoped CSS update (Svelte/Vue)
+     * Updates only the affected component's styles
+     */
+    private handleScopedCSSUpdate;
+    /**
+     * Find islands that use a specific CSS module
+     */
+    private findIslandsUsingCSSModule;
+    /**
+     * Find islands using a specific component file
+     */
+    private findIslandsUsingComponent;
+    /**
+     * Trigger re-render of an island to apply new CSS module classes
+     */
+    private triggerIslandRerender;
+    /**
+     * Dispatch CSS update event for feedback
+     */
+    private dispatchCSSUpdateEvent;
+    /**
+     * Normalize a file path for comparison
+     */
+    private normalizePath;
+    /**
+     * Get directory from a file path
+     */
+    private getDirectory;
+    /**
+     * Get file ID from path (for Vite's data-vite-dev-id)
+     */
+    private getFileId;
+    /**
+     * Clear cached mappings
+     */
+    clearCache(): void;
+    /**
+     * Register an island as using a CSS module
+     * Useful for explicit tracking
+     */
+    registerCSSModuleUsage(cssPath: string, island: HTMLElement): void;
+}
+/**
+ * Get or create the global CSS HMR handler instance
+ */
+export declare function getCSSHMRHandler(): CSSHMRHandler;