@useavalon/avalon 0.1.2 → 0.1.4

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@useavalon/avalon",
-	"version": "0.1.2",
+	"version": "0.1.4",
 	"description": "Multi-framework islands architecture for the modern web",
 	"license": "MIT",
 	"type": "module",

package/src/core/integrations/registry.ts

@@ -94,56 +94,36 @@ export class IntegrationRegistry {
     }
   }
 
-  /**
-   * Internal method to load integration module
-   * Note: In development mode, integrations should be pre-loaded via preloader.ts
-   * before Vite's SSR context starts. This method is a fallback for production
-   * or when integrations weren't pre-loaded.
-   */
   private async loadIntegration(name: string): Promise<Integration> {
+    const integrationKey = `${name}Integration`;
+
+    // 1. Try loading from the installed npm package first (@useavalon/<name>)
+    try {
+      const packageName = `@useavalon/${name}`;
+      const module = await import(/* @vite-ignore */ packageName);
+      const integration = module[integrationKey] || module.default;
+      if (integration) return integration as Integration;
+    } catch {
+      // Package not installed or import failed — try monorepo path
+    }
+
+    // 2. Monorepo fallback: resolve via packages/integrations/<name>/mod.ts
     try {
-      // Use absolute file:// URL to bypass Vite's module resolution
-      // This ensures we use Deno's native import which handles npm: specifiers correctly
       const monorepoRoot = findMonorepoRoot();
       const integrationPath = join(monorepoRoot, "packages", "integrations", name, "mod.ts");
       const fileUrl = `file://${integrationPath}`;
-      
-      // Dynamic import with file:// URL bypasses Vite's SSR module loader
       const module = await import(/* @vite-ignore */ fileUrl);
-      
-      // Look for the integration export (e.g., preactIntegration)
-      const integrationKey = `${name}Integration`;
       const integration = module[integrationKey] || module.default;
-
-      if (!integration) {
-        throw new Error(
-          `Integration module '${name}' does not export '${integrationKey}' or a default export`
-        );
-      }
-
-      return integration as Integration;
-    } catch (error) {
-      // Check if this is a Vite SSR context issue
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      const isViteIssue = errorMessage.includes('ERR_UNSUPPORTED_ESM_URL_SCHEME') ||
-                          errorMessage.includes('Only file and data URLs are supported');
-      
-      if (isViteIssue) {
-        throw new Error(
-          `Integration '${name}' could not be loaded within Vite's SSR context. ` +
-          `This usually means the integration wasn't pre-loaded at server startup. ` +
-          `Make sure preloadIntegrationsNative() is called before Vite server starts.`,
-          { cause: error }
-        );
-      }
-      
-      throw new Error(
-        `Failed to load integration for framework '${name}'. ` +
-        `Make sure @useavalon/${name} is installed.\n` +
-        `Install it with: bun add @useavalon/${name}`,
-        { cause: error }
-      );
+      if (integration) return integration as Integration;
+    } catch {
+      // Monorepo path also failed
     }
+
+    throw new Error(
+      `Failed to load integration for framework '${name}'. ` +
+      `Make sure @useavalon/${name} is installed.\n` +
+      `Install it with: bun add @useavalon/${name}`,
+    );
   }
 
   /**

package/src/vite-plugin/nitro-integration.ts

@@ -10,6 +10,8 @@
 import type { Plugin, ViteDevServer } from 'vite';
 import { nitro as nitroVitePlugin } from 'nitro/vite';
 import { stat as fsStat } from 'node:fs/promises';
+import { createRequire } from 'node:module';
+import { dirname, join } from 'node:path';
 import type { ResolvedAvalonConfig } from './types.ts';
 import { createNitroConfig, type AvalonNitroConfig, type NitroConfigOutput } from '../nitro/config.ts';
 import type { PageModule } from '../nitro/types.ts';
@@ -27,6 +29,26 @@ import { collectCssFromModuleGraph, injectSsrCss } from '../render/collect-css.t
 import { getUniversalCSSForHead } from '../islands/universal-css-collector.ts';
 import { getUniversalHeadForInjection } from '../islands/universal-head-collector.ts';
 
+/**
+ * Resolves the absolute path to a file inside @useavalon/avalon's source tree.
+ */
+function resolveAvalonPackagePath(relativePath: string): string {
+	const require = createRequire(import.meta.url);
+	const modEntry = require.resolve('@useavalon/avalon');
+	const pkgRoot = dirname(modEntry);
+	return join(pkgRoot, relativePath);
+}
+
+/**
+ * Resolves the absolute path to a file inside an @useavalon/<name> integration package.
+ */
+function resolveIntegrationPackagePath(name: string, relativePath: string): string {
+	const require = createRequire(import.meta.url);
+	const modEntry = require.resolve(`@useavalon/${name}`);
+	const pkgRoot = dirname(modEntry);
+	return join(pkgRoot, relativePath);
+}
+
 export const VIRTUAL_MODULE_IDS = {
 	PAGE_ROUTES: 'virtual:avalon/page-routes',
 	ISLAND_MANIFEST: 'virtual:avalon/island-manifest',
@@ -342,18 +364,16 @@ async function handle404(
 async function prewarmCoreModules(server: ViteDevServer, verbose?: boolean): Promise<void> {
 	const prewarmStart = performance.now();
 
+	const frameworkNames = ['react', 'vue', 'solid', 'svelte', 'lit', 'preact'] as const;
+
 	const coreModules = [
-		// SSR infrastructure
-		{ path: '../packages/avalon/src/render/ssr.ts', assignTo: 'ssr' },
-		{ path: '../packages/avalon/src/core/layout/enhanced-layout-resolver.ts', assignTo: 'layout' },
-		{ path: '../packages/avalon/src/middleware/index.ts', assignTo: null },
-		// Framework renderers — prewarm so first island render is fast
-		{ path: '../packages/integrations/react/server/renderer.ts', assignTo: null },
-		{ path: '../packages/integrations/vue/server/renderer.ts', assignTo: null },
-		{ path: '../packages/integrations/solid/server/renderer.ts', assignTo: null },
-		{ path: '../packages/integrations/svelte/server/renderer.ts', assignTo: null },
-		{ path: '../packages/integrations/lit/server/renderer.ts', assignTo: null },
-		{ path: '../packages/integrations/preact/server/renderer.ts', assignTo: null },
+		{ path: resolveAvalonPackagePath('src/render/ssr.ts'), assignTo: 'ssr' as string | null },
+		{ path: resolveAvalonPackagePath('src/core/layout/enhanced-layout-resolver.ts'), assignTo: 'layout' as string | null },
+		{ path: resolveAvalonPackagePath('src/middleware/index.ts'), assignTo: null as string | null },
+		...frameworkNames.map(name => ({
+			path: resolveIntegrationPackagePath(name, 'server/renderer.ts'),
+			assignTo: null as string | null,
+		})),
 	];
 
 	const results = await Promise.allSettled(
@@ -1198,14 +1218,14 @@ async function renderPageToHtml(
 
 	try {
 		if (!cachedSSRModule) {
-			cachedSSRModule = await server.ssrLoadModule('../packages/avalon/src/render/ssr.ts');
+			cachedSSRModule = await server.ssrLoadModule(resolveAvalonPackagePath('src/render/ssr.ts'));
 		}
 		// cachedSSRModule is the dynamically-loaded render/ssr.ts module;
 		// expected exports: renderToHtml, renderToHtmlWithLayouts
 		const ssrModule = cachedSSRModule as Record<string, unknown>;
 
 		if (!cachedLayoutModule) {
-			cachedLayoutModule = await server.ssrLoadModule('../packages/avalon/src/core/layout/enhanced-layout-resolver.ts');
+			cachedLayoutModule = await server.ssrLoadModule(resolveAvalonPackagePath('src/core/layout/enhanced-layout-resolver.ts'));
 		}
 		// cachedLayoutModule is the dynamically-loaded enhanced-layout-resolver.ts module;
 		// expected exports: EnhancedLayoutResolver, EnhancedLayoutResolverUtils

package/src/vite-plugin/plugin.ts

@@ -16,6 +16,8 @@ import type {
   IntegrationName,
   ResolvedAvalonConfig,
 } from "./types.ts";
+import { createRequire } from "node:module";
+import { dirname, join } from "node:path";
 import { resolveConfig, checkDirectoriesExist } from "./config.ts";
 import { activateIntegrations, activateSingleIntegration } from "./integration-activator.ts";
 import { discoverIntegrationsFromIslandUsage } from "./auto-discover.ts";
@@ -254,11 +256,45 @@ export async function avalon(config?: AvalonPluginConfig): Promise<PluginOption[
     verbose: preResolvedConfig.verbose,
   });
 
+  // Pre-resolve paths for standalone projects.
+  // In the monorepo www/ project these are handled by manual resolve.alias.
+  const require = createRequire(import.meta.url);
+
+  let clientMainResolved: string | null = null;
+  try {
+    const clientEntry = require.resolve("@useavalon/avalon/client");
+    clientMainResolved = join(dirname(clientEntry), "main.js");
+  } catch {
+    // Monorepo — www/ sets its own alias
+  }
+
+  // Resolve /@useavalon/*/client virtual imports used by main.js
+  const integrationClientMap: Record<string, string | null> = {};
+  for (const name of ['preact', 'react', 'vue', 'svelte', 'solid', 'lit', 'qwik']) {
+    try {
+      integrationClientMap[`/@useavalon/${name}/client`] = require.resolve(`@useavalon/${name}/client`);
+    } catch {
+      integrationClientMap[`/@useavalon/${name}/client`] = null;
+    }
+  }
+
   // The main Avalon plugin
   const avalonPlugin: Plugin = {
     name: "avalon",
     enforce: "pre",
 
+    config() {
+      // Vite 8 uses OXC for TS/JSX transform. When the project tsconfig sets
+      // jsx: "react-jsx", Vite passes jsx options to OXC for ALL .ts files
+      // including those in node_modules/@useavalon. OXC rejects this for plain
+      // .ts files that don't contain JSX. Exclude @useavalon packages from OXC.
+      return {
+        oxc: {
+          exclude: [/node_modules\/@useavalon\//],
+        },
+      };
+    },
+
     configResolved(resolvedViteConfig: ResolvedConfig) {
       viteConfig = resolvedViteConfig;
       const isDev = resolvedViteConfig.command === "serve";
@@ -269,6 +305,16 @@ export async function avalon(config?: AvalonPluginConfig): Promise<PluginOption[
       checkDirectoriesExist(resolvedConfig, resolvedViteConfig.root);
     },
 
+    resolveId(id: string) {
+      if (id === "/src/client/main.js" && clientMainResolved) {
+        return clientMainResolved;
+      }
+      if (id in integrationClientMap && integrationClientMap[id]) {
+        return integrationClientMap[id];
+      }
+      return null;
+    },
+
     async buildStart() {
       await runAutoDiscovery(resolvedConfig, viteConfig?.root, activeIntegrations);
       runValidation(resolvedConfig, activeIntegrations);