@despia/local 1.0.0 → 1.0.2

package/README.md

@@ -353,12 +353,12 @@ npx despia-local [outputDir] [entryHtml]
 ```javascript
 // vite.config.js
 import { defineConfig } from 'vite';
-import { despiaOfflinePlugin } from '@despia/local/vite';
+import { despiaLocalPlugin } from '@despia/local/vite';
 
 export default defineConfig({
   plugins: [
     // ... your other plugins
-    despiaOfflinePlugin({
+    despiaLocalPlugin({
       outDir: 'dist',        // optional, default: 'dist'
       entryHtml: 'index.html' // optional, default: 'index.html'
     })
@@ -378,13 +378,13 @@ export default defineConfig({
 
 ```javascript
 // webpack.config.js
-const DespiaOfflinePlugin = require('@despia/local/webpack');
+const DespiaLocalPlugin = require('@despia/local/webpack');
 
 module.exports = {
   // ... your config
   plugins: [
     // ... your other plugins
-    new DespiaOfflinePlugin({
+    new DespiaLocalPlugin({
       outDir: 'dist',        // optional, default: 'dist'
       entryHtml: 'index.html' // optional, default: 'index.html'
     })
@@ -402,13 +402,13 @@ module.exports = {
 
 ```javascript
 // rollup.config.js
-import { despiaOffline } from '@despia/local/rollup';
+import { despiaLocal } from '@despia/local/rollup';
 
 export default {
   // ... your config
   plugins: [
     // ... your other plugins
-    despiaOffline({
+    despiaLocal({
       outDir: 'dist',
       entryHtml: 'index.html'
     })
@@ -418,25 +418,28 @@ export default {
 
 ### Next.js
 
+**For static export (recommended for static sites):**
+
 ```javascript
 // next.config.js
-const withDespiaOffline = require('@despia/local/next');
+const withDespiaLocal = require('@despia/local/next');
 
-module.exports = withDespiaOffline({
+module.exports = withDespiaLocal({
   entryHtml: 'index.html',
-  outDir: '.next' // or 'out' for static export
+  outDir: 'out' // Next.js static export directory
 })({
+  output: 'export',
   // your Next.js config
 });
 ```
 
-**For static export:**
+**For static export (alternative):**
 
 ```javascript
 // next.config.js
-const withDespiaOffline = require('@despia/local/next');
+const withDespiaLocal = require('@despia/local/next');
 
-module.exports = withDespiaOffline({
+module.exports = withDespiaLocal({
   outDir: 'out', // Next.js static export directory
   entryHtml: 'index.html'
 })({
@@ -445,29 +448,75 @@ module.exports = withDespiaOffline({
 });
 ```
 
-**Alternative: Webpack Plugin Approach**
+**Alternative: Webpack Plugin Approach (works best for static export):**
 
 ```javascript
 // next.config.js
-const DespiaOfflinePlugin = require('@despia/local/webpack');
+const DespiaLocalPlugin = require('@despia/local/webpack');
 
 module.exports = {
+  output: 'export', // For static export
   webpack: (config) => {
     config.plugins.push(
-      new DespiaOfflinePlugin({ outDir: '.next' })
+      new DespiaLocalPlugin({ outDir: 'out' })
     );
     return config;
   }
 };
 ```
 
+**Note**: The webpack plugin approach works best for static export. For SSR apps, use the post-build script approach described below.
+
+**For SSR (Server-Side Rendering) apps:**
+
+SSR Next.js apps require special handling because:
+- Client assets are in `.next/static/` directory (not `.next/`)
+- No static HTML files exist (pages are server-rendered)
+- Manifest should only include client-side assets (JS, CSS, images)
+- Server-side code in `.next/server/` should NOT be included
+
+**Recommended approach for SSR (most reliable):**
+
+Use a post-build script in your `package.json`:
+
+```json
+{
+  "scripts": {
+    "build": "next build",
+    "postbuild": "despia-local .next/static"
+  }
+}
+```
+
+This approach:
+- Runs after Next.js build completes
+- Targets `.next/static/` where all client assets are stored
+- Works reliably for both SSR and static export
+- No `entryHtml` needed (SSR apps don't have static HTML files)
+
+**Alternative: Using the plugin (may have timing issues):**
+
+```javascript
+// next.config.js
+const withDespiaLocal = require('@despia/local/next');
+
+module.exports = withDespiaLocal({
+  // entryHtml is optional for SSR (not used)
+  outDir: '.next/static'  // Target client assets directory
+})({
+  // your Next.js config (SSR mode - no output: 'export')
+});
+```
+
+**Note**: The plugin approach may not work reliably for SSR because Next.js doesn't provide a reliable build completion hook. The post-build script approach is recommended for SSR apps.
+
 ### Nuxt
 
 ```javascript
 // nuxt.config.js
 export default {
   modules: ['@despia/local/nuxt'],
-  despiaOffline: {
+  despiaLocal: {
     entryHtml: 'index.html'
   }
 }
@@ -476,9 +525,9 @@ export default {
 **Or as a local module:**
 
 ```javascript
-// modules/despia-offline.js
-import DespiaOfflineModule from '@despia/local/nuxt';
-export default DespiaOfflineModule;
+// modules/despia-local.js
+import DespiaLocalModule from '@despia/local/nuxt';
+export default DespiaLocalModule;
 ```
 
 ### SvelteKit
@@ -486,12 +535,12 @@ export default DespiaOfflineModule;
 ```javascript
 // vite.config.js
 import { sveltekit } from '@sveltejs/kit/vite';
-import { despiaOfflineSvelteKit } from '@despia/local/sveltekit';
+import { despiaLocalSvelteKit } from '@despia/local/sveltekit';
 
 export default {
   plugins: [
     sveltekit(),
-    despiaOfflineSvelteKit({
+    despiaLocalSvelteKit({
       entryHtml: 'index.html'
     })
   ]
@@ -503,11 +552,11 @@ export default {
 ```javascript
 // astro.config.mjs
 import { defineConfig } from 'astro/config';
-import despiaOffline from '@despia/local/astro';
+import despiaLocal from '@despia/local/astro';
 
 export default defineConfig({
   integrations: [
-    despiaOffline({
+    despiaLocal({
       entryHtml: 'index.html',
       outDir: 'dist'
     })
@@ -520,12 +569,12 @@ export default defineConfig({
 ```javascript
 // vite.config.js (Remix uses Vite)
 import { remix } from '@remix-run/dev';
-import { despiaOfflineRemix } from '@despia/local/remix';
+import { despiaLocalRemix } from '@despia/local/remix';
 
 export default {
   plugins: [
     remix(),
-    despiaOfflineRemix({
+    despiaLocalRemix({
       entryHtml: 'index.html',
       outDir: 'build/client'
     })
@@ -537,13 +586,13 @@ export default {
 
 ```javascript
 import { build } from 'esbuild';
-import { despiaOfflineEsbuild } from '@despia/local/esbuild';
+import { despiaLocalEsbuild } from '@despia/local/esbuild';
 
 await build({
   entryPoints: ['src/index.js'],
   outdir: 'dist',
   plugins: [
-    despiaOfflineEsbuild({
+    despiaLocalEsbuild({
       outDir: 'dist',
       entryHtml: 'index.html'
     })
@@ -618,12 +667,12 @@ The generated `despia/local.json` file contains a sorted JSON array of root-rela
 // vite.config.js
 import { defineConfig } from 'vite';
 import react from '@vitejs/plugin-react';
-import { despiaOfflinePlugin } from '@despia/local/vite';
+import { despiaLocalPlugin } from '@despia/local/vite';
 
 export default defineConfig({
   plugins: [
     react(),
-    despiaOfflinePlugin()
+    despiaLocalPlugin()
   ]
 });
 ```
@@ -634,12 +683,12 @@ export default defineConfig({
 // vite.config.js
 import { defineConfig } from 'vite';
 import vue from '@vitejs/plugin-vue';
-import { despiaOfflinePlugin } from '@despia/local/vite';
+import { despiaLocalPlugin } from '@despia/local/vite';
 
 export default defineConfig({
   plugins: [
     vue(),
-    despiaOfflinePlugin()
+    despiaLocalPlugin()
   ]
 });
 ```
@@ -668,11 +717,11 @@ export default defineConfig({
 
 ```javascript
 // webpack.config.js
-const DespiaOfflinePlugin = require('@despia/local/webpack');
+const DespiaLocalPlugin = require('@despia/local/webpack');
 
 module.exports = {
   plugins: [
-    new DespiaOfflinePlugin({ outDir: 'dist' })
+    new DespiaLocalPlugin({ outDir: 'dist' })
   ]
 };
 ```
@@ -683,12 +732,12 @@ module.exports = {
 // vite.config.js
 import { defineConfig } from 'vite';
 import { svelte } from '@sveltejs/vite-plugin-svelte';
-import { despiaOfflinePlugin } from '@despia/local/vite';
+import { despiaLocalPlugin } from '@despia/local/vite';
 
 export default defineConfig({
   plugins: [
     svelte(),
-    despiaOfflinePlugin()
+    despiaLocalPlugin()
   ]
 });
 ```
@@ -733,6 +782,30 @@ The generated manifest is then used by Despia during app hydration and updates t
 - Paths starting with `/` are preserved as-is
 - Windows backslashes are converted to forward slashes
 
+### Next.js SSR Issues
+
+**Manifest not generated for SSR app:**
+
+1. Ensure you're targeting `.next/static/` directory (not `.next/`)
+2. Use the post-build script approach: `"postbuild": "despia-local .next/static"`
+3. Verify build completed successfully: `next build` should finish without errors
+4. Check that `.next/static/` directory exists after build
+5. The plugin approach may not work reliably for SSR - prefer post-build script
+
+**Missing assets in SSR manifest:**
+
+- SSR apps only need client assets (JS, CSS, images)
+- Server-side code in `.next/server/` is NOT included (correct behavior)
+- Only assets in `.next/static/` should be in the manifest
+- Verify you're scanning `.next/static/` not `.next/` or `.next/server/`
+
+**Wrong directory for SSR:**
+
+If you see errors about missing directories:
+- For SSR: Use `.next/static/` (client assets only)
+- For static export: Use `out/` (full static site)
+- Never use `.next/server/` (server code, not needed for manifest)
+
 ## Contributing
 
 Contributions welcome! Please open an issue or submit a pull request.

package/generate-offline-manifest.js

@@ -14,21 +14,81 @@
  */
 
 import { generateManifest } from './src/core.js';
-import { resolve } from 'path';
+import { resolve, join } from 'path';
+import { existsSync } from 'fs';
 
 // Get command line arguments
 const outputDir = process.argv[2] || 'dist';
 const entryHtml = process.argv[3] || 'index.html';
 
+// Detect Next.js SSR context
+const isNextJsDir = outputDir.includes('.next');
+const isNextJsStatic = outputDir.includes('.next/static') || outputDir === '.next/static';
+const isNextJsRoot = outputDir === '.next';
+const isNextJsServer = outputDir.includes('.next/server');
+
+// Determine if we should skip entryHtml (for SSR apps)
+const skipEntryHtml = isNextJsStatic || isNextJsServer;
+
+// Provide helpful messages for Next.js
+if (isNextJsDir && !isNextJsStatic && !isNextJsServer) {
+  if (isNextJsRoot) {
+    console.warn('⚠ Warning: Scanning .next/ directory directly.');
+    console.warn('💡 For SSR apps, use: despia-local .next/static');
+    console.warn('💡 For static export, use: despia-local out');
+  }
+}
+
+if (isNextJsServer) {
+  console.error('❌ Error: .next/server/ contains server-side code, not client assets.');
+  console.error('💡 For SSR apps, use: despia-local .next/static');
+  process.exit(1);
+}
+
 try {
-  console.log(`Scanning ${resolve(process.cwd(), outputDir)} for assets...`);
-  const paths = generateManifest({ outputDir, entryHtml });
+  const resolvedPath = resolve(process.cwd(), outputDir);
+  console.log(`Scanning ${resolvedPath} for assets...`);
+  
+  // Check if directory exists, and provide helpful suggestions for Next.js
+  if (!existsSync(resolvedPath)) {
+    if (isNextJsRoot) {
+      console.error(`❌ Directory "${resolvedPath}" does not exist.`);
+      console.error('💡 For SSR apps, try: despia-local .next/static');
+      console.error('💡 For static export, try: despia-local out');
+    }
+    throw new Error(`Output directory "${resolvedPath}" does not exist.`);
+  }
+  
+  // Check for Next.js static directory and suggest if scanning wrong location
+  if (isNextJsRoot && existsSync(join(resolvedPath, 'static'))) {
+    console.warn('⚠ Found .next/static/ subdirectory.');
+    console.warn('💡 For SSR apps, consider scanning .next/static directly for better results.');
+  }
+  
+  const paths = generateManifest({ 
+    outputDir, 
+    entryHtml,
+    skipEntryHtml 
+  });
   
   console.log(`✓ Generated despia/local.json`);
   console.log(`✓ Included ${paths.length} assets`);
-  console.log(`✓ Entry HTML: /${entryHtml}`);
+  if (!skipEntryHtml) {
+    console.log(`✓ Entry HTML: /${entryHtml}`);
+  } else {
+    console.log(`✓ Skipped entry HTML (SSR mode)`);
+  }
 } catch (error) {
-  console.error(`Error: ${error.message}`);
-  console.error('Please run this script after your build completes.');
+  console.error(`❌ Error: ${error.message}`);
+  console.error('💡 Please run this script after your build completes.');
+  
+  // Additional help for Next.js
+  if (isNextJsDir) {
+    console.error('');
+    console.error('Next.js tips:');
+    console.error('  - SSR apps: Use "despia-local .next/static"');
+    console.error('  - Static export: Use "despia-local out"');
+  }
+  
   process.exit(1);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@despia/local",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "Universal build plugin to generate despia/local.json manifest for offline caching in Despia web-native apps. Supports Vite, Webpack, Rollup, Next.js, Nuxt, SvelteKit, Astro, Remix, esbuild, Parcel, and more.",
   "type": "module",
   "main": "./src/core.js",

package/src/astro.js

@@ -3,11 +3,11 @@
  * 
  * Usage in astro.config.mjs:
  *   import { defineConfig } from 'astro/config';
- *   import despiaOffline from '@despia/local/astro';
+ *   import despiaLocal from '@despia/local/astro';
  *   
  *   export default defineConfig({
  *     integrations: [
- *       despiaOffline({ entryHtml: 'index.html' })
+ *       despiaLocal({ entryHtml: 'index.html' })
  *     ]
  *   });
  */
@@ -15,11 +15,11 @@
 import { generateManifest } from './core.js';
 import { fileURLToPath } from 'url';
 
-export default function despiaOfflineIntegration(options = {}) {
+export default function despiaLocalIntegration(options = {}) {
   const { entryHtml = 'index.html', outDir = 'dist' } = options;
 
   return {
-    name: 'despia-offline',
+    name: 'despia-local',
     hooks: {
       'astro:build:done': async ({ dir }) => {
         // Astro provides dir as a URL object, convert to path

package/src/core.js

@@ -51,9 +51,10 @@ export function collectFiles(dir, baseDir = dir) {
  * @param {string} options.outputDir - Output directory path
  * @param {string} options.entryHtml - Entry HTML filename (default: 'index.html')
  * @param {string[]} options.additionalPaths - Additional paths to include
+ * @param {boolean} options.skipEntryHtml - Skip adding entry HTML to manifest (for SSR apps)
  * @returns {string[]} Array of all asset paths
  */
-export function generateManifest({ outputDir, entryHtml = 'index.html', additionalPaths = [] }) {
+export function generateManifest({ outputDir, entryHtml = 'index.html', additionalPaths = [], skipEntryHtml = false }) {
   const outputPath = resolve(process.cwd(), outputDir);
   const manifestPath = join(outputPath, 'despia', 'local.json');
   
@@ -71,11 +72,13 @@ export function generateManifest({ outputDir, entryHtml = 'index.html', addition
     assetPaths.add(normalizedPath);
   });
   
-  // Ensure entry HTML is included
-  const entryPath = entryHtml.startsWith('/') 
-    ? entryHtml 
-    : '/' + entryHtml;
-  assetPaths.add(entryPath);
+  // Ensure entry HTML is included (unless skipped for SSR apps)
+  if (!skipEntryHtml) {
+    const entryPath = entryHtml.startsWith('/') 
+      ? entryHtml 
+      : '/' + entryHtml;
+    assetPaths.add(entryPath);
+  }
   
   // Convert to sorted array
   const sortedPaths = Array.from(assetPaths).sort();

package/src/esbuild.js

@@ -3,21 +3,21 @@
  * 
  * Usage:
  *   import { build } from 'esbuild';
- *   import { despiaOfflineEsbuild } from '@despia/local/esbuild';
+ *   import { despiaLocalEsbuild } from '@despia/local/esbuild';
  *   
  *   await build({
- *     plugins: [despiaOfflineEsbuild({ outDir: 'dist' })]
+ *     plugins: [despiaLocalEsbuild({ outDir: 'dist' })]
  *   });
  */
 
 import { generateManifest } from './core.js';
 import { relative } from 'path';
 
-export function despiaOfflineEsbuild(options = {}) {
+export function despiaLocalEsbuild(options = {}) {
   const { outDir = 'dist', entryHtml = 'index.html' } = options;
 
   return {
-    name: 'despia-offline',
+    name: 'despia-local',
     setup(build) {
       build.onEnd(async (result) => {
         if (result.errors.length > 0) {

package/src/index.js

@@ -4,13 +4,13 @@
  */
 
 export { generateManifest, collectFiles } from './core.js';
-export { despiaOfflinePlugin } from './vite.js';
-export { default as DespiaOfflinePlugin } from './webpack.js';
-export { despiaOffline } from './rollup.js';
-export { withDespiaOffline } from './next.js';
-export { default as DespiaOfflineModule } from './nuxt.js';
-export { despiaOfflineSvelteKit } from './sveltekit.js';
-export { default as despiaOfflineIntegration } from './astro.js';
-export { despiaOfflineRemix } from './remix.js';
-export { despiaOfflineEsbuild } from './esbuild.js';
-export { default as DespiaOfflineParcel } from './parcel.js';
+export { despiaLocalPlugin } from './vite.js';
+export { default as DespiaLocalPlugin } from './webpack.js';
+export { despiaLocal } from './rollup.js';
+export { withDespiaLocal } from './next.js';
+export { default as DespiaLocalModule } from './nuxt.js';
+export { despiaLocalSvelteKit } from './sveltekit.js';
+export { default as despiaLocalIntegration } from './astro.js';
+export { despiaLocalRemix } from './remix.js';
+export { despiaLocalEsbuild } from './esbuild.js';
+export { default as DespiaLocalParcel } from './parcel.js';

package/src/next.js

@@ -1,48 +1,73 @@
 /**
  * Next.js integration for generating despia/local.json manifest
  * 
- * Usage in next.config.js:
- *   const withDespiaOffline = require('@despia/local/next');
- *   module.exports = withDespiaOffline({
+ * Usage for static export:
+ *   const withDespiaLocal = require('@despia/local/next');
+ *   module.exports = withDespiaLocal({
  *     entryHtml: 'index.html',
- *     outDir: '.next' // or 'out' for static export
+ *     outDir: 'out' // Next.js static export directory
  *   })({
+ *     output: 'export',
  *     // your next config
  *   });
  * 
- * Or use the webpack plugin approach:
- *   const DespiaOfflinePlugin = require('@despia/local/webpack');
+ * Usage for SSR (recommended: use post-build script):
+ *   // package.json
+ *   {
+ *     "scripts": {
+ *       "build": "next build",
+ *       "postbuild": "despia-local .next/static"
+ *     }
+ *   }
+ * 
+ * Or use the webpack plugin approach (works best for static export):
+ *   const DespiaLocalPlugin = require('@despia/local/webpack');
  *   module.exports = {
  *     webpack: (config) => {
- *       config.plugins.push(new DespiaOfflinePlugin({ outDir: '.next' }));
+ *       config.plugins.push(new DespiaLocalPlugin({ outDir: '.next' }));
  *       return config;
  *     }
  *   };
  */
 
 import { generateManifest } from './core.js';
-import DespiaOfflinePlugin from './webpack.js';
+import DespiaLocalPlugin from './webpack.js';
 
-export function withDespiaOffline(pluginOptions = {}) {
-  const offlineConfig = {
+export function withDespiaLocal(pluginOptions = {}) {
+  const localConfig = {
     outDir: pluginOptions.outDir || '.next',
     entryHtml: pluginOptions.entryHtml || 'index.html',
     ...pluginOptions
   };
 
   return (nextConfig = {}) => {
+    // Detect if this is static export or SSR
+    const isStaticExport = nextConfig.output === 'export';
     const existingWebpack = nextConfig.webpack;
 
     return {
       ...nextConfig,
       webpack: (config, options) => {
-        // Add Despia Offline plugin
-        config.plugins.push(
-          new DespiaOfflinePlugin({
-            outDir: offlineConfig.outDir,
-            entryHtml: offlineConfig.entryHtml
-          })
-        );
+        // Only add webpack plugin for client builds (not server builds)
+        // For SSR, the webpack plugin will target .next/static during client build
+        // For static export, it works normally
+        if (!options.isServer) {
+          // Determine the correct output directory
+          let targetOutDir = localConfig.outDir;
+          
+          // For SSR apps, target .next/static where client assets are stored
+          if (!isStaticExport && targetOutDir === '.next') {
+            targetOutDir = '.next/static';
+          }
+          
+          config.plugins.push(
+            new DespiaLocalPlugin({
+              outDir: targetOutDir,
+              entryHtml: localConfig.entryHtml,
+              skipEntryHtml: !isStaticExport // Skip entryHtml for SSR
+            })
+          );
+        }
 
         // Call existing webpack config if present
         if (typeof existingWebpack === 'function') {
@@ -56,4 +81,4 @@ export function withDespiaOffline(pluginOptions = {}) {
 }
 
 // Also export as CommonJS for Next.js compatibility
-export default withDespiaOffline;
+export default withDespiaLocal;

package/src/nuxt.js

@@ -4,24 +4,24 @@
  * Usage in nuxt.config.js:
  *   export default {
  *     modules: ['@despia/local/nuxt'],
- *     despiaOffline: {
+ *     despiaLocal: {
  *       entryHtml: 'index.html'
  *     }
  *   }
  * 
  * Or use as a Nuxt module in modules/ directory:
- *   // modules/despia-offline.js
- *   import DespiaOfflineModule from '@despia/local/nuxt';
- *   export default DespiaOfflineModule;
+ *   // modules/despia-local.js
+ *   import DespiaLocalModule from '@despia/local/nuxt';
+ *   export default DespiaLocalModule;
  */
 
 import { generateManifest } from './core.js';
 
-export default function DespiaOfflineModule(moduleOptions) {
+export default function DespiaLocalModule(moduleOptions) {
   const options = {
     entryHtml: 'index.html',
     ...moduleOptions,
-    ...(this.options?.despiaOffline || {})
+    ...(this.options?.despiaLocal || {})
   };
 
   // Hook into Nuxt build completion

package/src/parcel.js

@@ -6,7 +6,7 @@
  * 
  *   "scripts": {
  *     "build": "parcel build",
- *     "postbuild": "despia-offline dist"
+ *     "postbuild": "despia-local dist"
  *   }
  * 
  * For Parcel 1.x, you can use this plugin, but the API may vary.
@@ -19,7 +19,7 @@ export default function(api) {
   const { outDir = 'dist', entryHtml = 'index.html' } = api.options || {};
 
   return {
-    name: 'despia-offline',
+    name: 'despia-local',
     async bundleEnd({ bundleGraph }) {
       const additionalPaths = [];
       
@@ -43,7 +43,7 @@ export default function(api) {
         console.log(`✓ Generated despia/local.json with ${paths.length} assets`);
       } catch (error) {
         console.error('Error generating despia/local.json:', error.message);
-        console.warn('💡 Tip: For Parcel projects, use the standalone CLI: "despia-offline dist"');
+        console.warn('💡 Tip: For Parcel projects, use the standalone CLI: "despia-local dist"');
       }
     }
   };

package/src/remix.js

@@ -3,23 +3,23 @@
  * 
  * Usage in remix.config.js or vite.config.js:
  *   import { remix } from '@remix-run/dev';
- *   import { despiaOfflineRemix } from '@despia/local/remix';
+ *   import { despiaLocalRemix } from '@despia/local/remix';
  *   
  *   export default {
  *     plugins: [
  *       remix(),
- *       despiaOfflineRemix({ entryHtml: 'index.html' })
+ *       despiaLocalRemix({ entryHtml: 'index.html' })
  *     ]
  *   }
  */
 
 import { generateManifest } from './core.js';
 
-export function despiaOfflineRemix(options = {}) {
+export function despiaLocalRemix(options = {}) {
   const { entryHtml = 'index.html', outDir = 'build/client' } = options;
 
   return {
-    name: 'despia-offline-remix',
+    name: 'despia-local-remix',
     apply: 'build',
     buildEnd() {
       // Remix outputs to build/client for client assets

package/src/rollup.js

@@ -10,11 +10,11 @@ import { generateManifest } from './core.js';
  * @param {string} options.outDir - Output directory (default: 'dist')
  * @param {string} options.entryHtml - Entry HTML file (default: 'index.html')
  */
-export function despiaOffline(options = {}) {
+export function despiaLocal(options = {}) {
   const { outDir = 'dist', entryHtml = 'index.html' } = options;
 
   return {
-    name: 'despia-offline',
+    name: 'despia-local',
     writeBundle(outputOptions, bundle) {
       const outputDir = outputOptions.dir || outDir;
       const additionalPaths = [];

package/src/sveltekit.js

@@ -3,23 +3,23 @@
  * 
  * Usage in vite.config.js:
  *   import { sveltekit } from '@sveltejs/kit/vite';
- *   import { despiaOfflineSvelteKit } from '@despia/local/sveltekit';
+ *   import { despiaLocalSvelteKit } from '@despia/local/sveltekit';
  *   
  *   export default {
  *     plugins: [
  *       sveltekit(),
- *       despiaOfflineSvelteKit({ entryHtml: 'index.html' })
+ *       despiaLocalSvelteKit({ entryHtml: 'index.html' })
  *     ]
  *   }
  */
 
 import { generateManifest } from './core.js';
 
-export function despiaOfflineSvelteKit(options = {}) {
+export function despiaLocalSvelteKit(options = {}) {
   const { entryHtml = 'index.html' } = options;
 
   return {
-    name: 'despia-offline-sveltekit',
+    name: 'despia-local-sveltekit',
     apply: 'build',
     buildEnd() {
       // SvelteKit outputs to build directory

package/src/turbopack.js

@@ -6,7 +6,7 @@
 
 import { generateManifest } from './core.js';
 
-export function despiaOfflineTurbopack(options = {}) {
+export function despiaLocalTurbopack(options = {}) {
   const { entryHtml = 'index.html', outDir = '.next' } = options;
 
   // Turbopack is used by Next.js, so we recommend using the Next.js integration
@@ -14,7 +14,7 @@ export function despiaOfflineTurbopack(options = {}) {
   console.warn('⚠ Turbopack: Use @despia/local/next instead for Next.js projects');
   
   return {
-    name: 'despia-offline-turbopack',
+    name: 'despia-local-turbopack',
     // Implementation would go here when Turbopack plugin API is stable
   };
 }

package/src/vite.js

@@ -11,11 +11,11 @@ import { generateManifest } from './core.js';
  * @param {string} options.outDir - Output directory (default: 'dist')
  * @param {string} options.entryHtml - Entry HTML file (default: 'index.html')
  */
-export function despiaOfflinePlugin(options = {}) {
+export function despiaLocalPlugin(options = {}) {
   const { outDir = 'dist', entryHtml = 'index.html' } = options;
 
   return {
-    name: 'despia-offline',
+    name: 'despia-local',
     apply: 'build',
     writeBundle(bundleOptions, bundle) {
       const outputDir = bundleOptions.dir || outDir;

package/src/webpack.js

@@ -4,19 +4,33 @@
 
 import { generateManifest } from './core.js';
 
-class DespiaOfflinePlugin {
+class DespiaLocalPlugin {
   constructor(options = {}) {
     this.options = {
       outDir: options.outDir || 'dist',
       entryHtml: options.entryHtml || 'index.html',
+      skipEntryHtml: options.skipEntryHtml || false,
       ...options
     };
   }
 
   apply(compiler) {
-    const pluginName = 'DespiaOfflinePlugin';
+    const pluginName = 'DespiaLocalPlugin';
     
     compiler.hooks.afterEmit.tapAsync(pluginName, (compilation, callback) => {
+      // Detect if this is a Next.js server build
+      // Next.js server builds have specific compiler name patterns
+      const compilerName = compilation.compiler.name || '';
+      const isNextJsServerBuild = compilerName.includes('server') || 
+                                   compilerName.includes('Server') ||
+                                   compilation.compiler.options?.target === 'node';
+      
+      // Skip manifest generation for server builds (SSR apps don't need server-side assets)
+      if (isNextJsServerBuild) {
+        callback();
+        return;
+      }
+      
       // Get output path from webpack compiler
       const outputPath = compilation.compiler.outputPath || this.options.outDir;
       const additionalPaths = [];
@@ -41,7 +55,8 @@ class DespiaOfflinePlugin {
         const paths = generateManifest({
           outputDir: outputPath,
           entryHtml: this.options.entryHtml,
-          additionalPaths
+          additionalPaths,
+          skipEntryHtml: this.options.skipEntryHtml
         });
         console.log(`✓ Generated despia/local.json with ${paths.length} assets`);
       } catch (error) {
@@ -53,4 +68,4 @@ class DespiaOfflinePlugin {
   }
 }
 
-export default DespiaOfflinePlugin;
+export default DespiaLocalPlugin;