@uniweb/build 0.8.19 → 0.8.21

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uniweb/build",
-  "version": "0.8.19",
+  "version": "0.8.21",
   "description": "Build tooling for the Uniweb Component Web Platform",
   "type": "module",
   "exports": {
@@ -17,7 +17,8 @@
     "./dev": "./src/dev/index.js",
     "./prerender": "./src/prerender.js",
     "./i18n": "./src/i18n/index.js",
-    "./search": "./src/search/index.js"
+    "./search": "./src/search/index.js",
+    "./import-map-plugin": "./src/import-map-plugin.js"
   },
   "files": [
     "src"
@@ -47,14 +48,15 @@
     "jest": "^29.7.0"
   },
   "dependencies": {
+    "esbuild": "^0.21.0 || ^0.23.0 || ^0.24.0 || ^0.25.0 || ^0.27.0",
     "js-yaml": "^4.1.0",
     "sharp": "^0.33.2",
     "@uniweb/theming": "0.1.2"
   },
   "optionalDependencies": {
-    "@uniweb/schemas": "0.2.1",
+    "@uniweb/runtime": "0.6.16",
     "@uniweb/content-reader": "1.1.4",
-    "@uniweb/runtime": "0.6.14"
+    "@uniweb/schemas": "0.2.1"
   },
   "peerDependencies": {
     "vite": "^5.0.0 || ^6.0.0 || ^7.0.0",
@@ -63,7 +65,7 @@
     "@tailwindcss/vite": "^4.0.0",
     "@vitejs/plugin-react": "^4.0.0 || ^5.0.0",
     "vite-plugin-svgr": "^4.0.0",
-    "@uniweb/core": "0.5.13"
+    "@uniweb/core": "0.5.15"
   },
   "peerDependenciesMeta": {
     "vite": {

package/src/import-map-plugin.js

@@ -0,0 +1,145 @@
+/**
+ * Import Map Plugin
+ *
+ * Shared Vite plugin that emits import-map bridge modules so that
+ * foundations loaded via dynamic import() can resolve bare specifiers
+ * (react, @uniweb/core, etc.) to the same instances used by the host app.
+ *
+ * Production: emits deterministic chunks at _importmap/*.js with explicit
+ * named re-exports, and injects a <script type="importmap"> into the HTML.
+ *
+ * Used by:
+ * - Site builds (runtime mode + extensions)  — packages/build/src/site/config.js
+ * - Runtime shell build                      — packages/runtime/vite.config.app.js
+ * - Dynamic-runtime (editor preview)         — packages/uniweb-editor/dynamic-runtime/
+ *
+ * @module @uniweb/build/import-map-plugin
+ */
+
+/** Default externals shared between foundations and hosts */
+const DEFAULT_EXTERNALS = [
+  'react',
+  'react-dom',
+  'react/jsx-runtime',
+  'react/jsx-dev-runtime',
+  '@uniweb/core',
+]
+
+const IMPORT_MAP_PREFIX = '\0importmap:'
+
+/** Valid JS identifier — filters out non-identifier keys from CJS modules */
+const isValidId = (k) => /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(k)
+
+/**
+ * Create the import map Vite plugin.
+ *
+ * @param {Object} [options]
+ * @param {string[]} [options.externals] - Package specifiers to bridge (default: react, react-dom, @uniweb/core, etc.)
+ * @param {string} [options.name] - Plugin name (default: 'uniweb:import-map')
+ * @param {string} [options.basePath] - Base path prefix for import map URLs in HTML (default: '/')
+ * @param {string} [options.resolveFrom] - Absolute path to resolve bare specifiers from inside virtual modules.
+ *   Needed when the host project doesn't have the externals as direct dependencies (e.g., site builds
+ *   under pnpm strict mode resolve from the foundation directory instead).
+ * @param {Object} [options.devBridges] - Map of specifier → dev-mode URL for import map injection in dev.
+ *   When provided, the import map is injected in both dev and prod (with different URLs).
+ *   When omitted, the import map is only injected in prod (dev uses other mechanisms like transformRequest).
+ * @returns {import('vite').Plugin}
+ */
+export function importMapPlugin({
+  externals = DEFAULT_EXTERNALS,
+  name = 'uniweb:import-map',
+  basePath = '/',
+  resolveFrom,
+  devBridges,
+} = {}) {
+  let isBuild = false
+
+  return {
+    name,
+
+    configResolved(config) {
+      isBuild = config.command === 'build'
+    },
+
+    resolveId(id, importer) {
+      if (id.startsWith(IMPORT_MAP_PREFIX)) return id
+      // Bare specifiers inside our virtual modules (e.g. '@uniweb/core' re-exported
+      // from '\0importmap:@uniweb/core') can't be resolved by Rollup because virtual
+      // modules have no filesystem context. When a resolveFrom path is provided,
+      // resolve from there (e.g. the foundation directory under pnpm strict mode).
+      if (resolveFrom && importer?.startsWith(IMPORT_MAP_PREFIX) && externals.includes(id)) {
+        return this.resolve(id, resolveFrom, { skipSelf: true })
+      }
+    },
+
+    async load(id) {
+      if (!id.startsWith(IMPORT_MAP_PREFIX)) return
+      const pkg = id.slice(IMPORT_MAP_PREFIX.length)
+
+      // Generate explicit named re-exports (not `export *`) because CJS
+      // packages like React only expose a default via `export *`, losing
+      // individual named exports (useState, jsx, etc.) that foundations need.
+      try {
+        const mod = await import(pkg)
+        const names = Object.keys(mod).filter((k) => k !== '__esModule' && isValidId(k))
+        const hasDefault = 'default' in mod
+        const named = names.filter((k) => k !== 'default')
+        const lines = []
+        if (named.length) {
+          lines.push(`export { ${named.join(', ')} } from '${pkg}'`)
+        }
+        if (hasDefault) {
+          lines.push(`export { default } from '${pkg}'`)
+        }
+        return lines.join('\n') || 'export {}'
+      } catch {
+        // Fallback: generic re-export (may not preserve named exports for CJS)
+        return `export * from '${pkg}'`
+      }
+    },
+
+    // Emit deterministic chunks for each external (production only).
+    // preserveSignature: 'exports-only' tells Rollup to preserve the original
+    // export names (useState, jsx, etc.) instead of mangling them.
+    buildStart() {
+      if (!isBuild) return
+      for (const ext of externals) {
+        this.emitFile({
+          type: 'chunk',
+          id: `${IMPORT_MAP_PREFIX}${ext}`,
+          fileName: `_importmap/${ext.replace(/\//g, '-')}.js`,
+          preserveSignature: 'exports-only',
+        })
+      }
+    },
+
+    // Inject the import map into the HTML.
+    // In prod: always injects with basePath-prefixed _importmap/ URLs.
+    // In dev: only injects if devBridges are provided (otherwise, the consumer
+    //   handles dev-mode resolution via other mechanisms like transformRequest).
+    transformIndexHtml: {
+      order: 'pre',
+      handler(html) {
+        const imports = {}
+
+        if (isBuild) {
+          for (const ext of externals) {
+            imports[ext] = `${basePath}_importmap/${ext.replace(/\//g, '-')}.js`
+          }
+        } else if (devBridges) {
+          Object.assign(imports, devBridges)
+        } else {
+          // No dev injection — consumer handles dev mode separately
+          return html
+        }
+
+        const importMap = JSON.stringify({ imports }, null, 2)
+        const script = `    <script type="importmap">\n${importMap}\n    </script>\n`
+        // Import map must appear before any module scripts
+        return html.replace('<head>', '<head>\n' + script)
+      },
+    },
+  }
+}
+
+export { DEFAULT_EXTERNALS }

package/src/prerender.js

@@ -403,6 +403,7 @@ export async function prerenderSite(siteDir, options = {}) {
     prefetchIcons,
     renderPage,
     injectPageContent,
+    generate404Html,
   } = await import('@uniweb/runtime/ssr')
 
   // Load default site content
@@ -545,6 +546,20 @@ export async function prerenderSite(siteDir, options = {}) {
       renderedFiles.push(outputPath)
       onProgress(`  → ${outputPath.replace(distDir, 'dist')}`)
     }
+
+    // Write 404.html — shared logic from @uniweb/runtime/ssr
+    const fallbackBaseHtml = injectBuildData(htmlShell, siteContent)
+    const { html: notFoundHtml, hasNotFoundPage } = generate404Html({
+      baseHtml: fallbackBaseHtml,
+      website,
+      siteContent,
+    })
+
+    const fallbackDir = routePrefix ? join(distDir, routePrefix.replace(/^\//, '')) : distDir
+    await mkdir(fallbackDir, { recursive: true })
+    await writeFile(join(fallbackDir, '404.html'), notFoundHtml)
+    const fallbackNote = hasNotFoundPage ? '404 page + SPA fallback' : 'SPA fallback'
+    onProgress(`  → ${routePrefix || ''}404.html (${fallbackNote})`)
   }
 
   onProgress(`\nPre-rendered ${renderedFiles.length} pages across ${localeConfigs.length} locale(s)`)

package/src/runtime-schema.js

@@ -228,6 +228,14 @@ export function extractRuntimeSchema(fullMeta) {
       if (fullMeta.data.inherit !== undefined) {
         runtime.inheritData = fullMeta.data.inherit
       }
+      // detail: false → opt out of single-item resolution on dynamic pages,
+      // returning the collection instead (minus the active item)
+      if (fullMeta.data.detail !== undefined) {
+        runtime.inheritDetail = fullMeta.data.detail
+      }
+      if (fullMeta.data.limit !== undefined) {
+        runtime.inheritLimit = fullMeta.data.limit
+      }
     }
   }
 

package/src/site/config.js

@@ -24,6 +24,7 @@ import { existsSync, readFileSync } from 'node:fs'
 import { resolve, dirname, join } from 'node:path'
 import yaml from 'js-yaml'
 import { generateEntryPoint, shouldRegenerateForFile } from '../generate-entry.js'
+import { importMapPlugin } from '../import-map-plugin.js'
 
 /**
  * Normalize a base path for Vite compatibility
@@ -343,105 +344,73 @@ export async function defineSiteConfig(options = {}) {
 
   if (noopFoundationPlugin) plugins.push(noopFoundationPlugin)
 
-  // Import map plugin for runtime mode production builds
+  // Import map plugin for runtime mode production builds.
   // Emits re-export modules for each externalized package (react, @uniweb/core, etc.)
-  // so the browser can resolve bare specifiers in the dynamically-imported foundation
-  const IMPORT_MAP_EXTERNALS = [
-    'react',
-    'react-dom',
-    'react/jsx-runtime',
-    'react/jsx-dev-runtime',
-    '@uniweb/core'
-  ]
-  const IMPORT_MAP_PREFIX = '\0importmap:'
-
-  const importMapPlugin = needsImportMap ? (() => {
-    let isBuild = false
-
-    return {
-      name: 'uniweb:import-map',
-
-      configResolved(config) {
-        isBuild = config.command === 'build'
-      },
-
-      resolveId(id, importer) {
-        if (id.startsWith(IMPORT_MAP_PREFIX)) return id
-        // Bare specifiers inside our virtual modules (e.g. '@uniweb/core' re-exported
-        // from '\0importmap:@uniweb/core') can't be resolved by Rollup because virtual
-        // modules have no filesystem context. Resolve from the foundation directory where
-        // @uniweb/core is a direct dependency (the site may not have it under pnpm strict).
-        if (importer?.startsWith(IMPORT_MAP_PREFIX) && IMPORT_MAP_EXTERNALS.includes(id)) {
-          const resolveFrom = foundationInfo.path
-            ? resolve(foundationInfo.path, 'package.json')
-            : resolve(siteRoot, 'main.js')
-          return this.resolve(id, resolveFrom, { skipSelf: true })
-        }
-      },
+  // so the browser can resolve bare specifiers in the dynamically-imported foundation.
+  // In dev mode, Vite's transformRequest() handles bare specifier resolution instead.
+  if (needsImportMap) {
+    plugins.push(importMapPlugin({
+      basePath: base || '/',
+      // Under pnpm strict mode, the site may not have @uniweb/core in its own
+      // node_modules. Resolve from the foundation directory where it's a direct dep.
+      resolveFrom: foundationInfo.path
+        ? resolve(foundationInfo.path, 'package.json')
+        : resolve(siteRoot, 'main.js'),
+    }))
+  }
 
-      async load(id) {
-        if (!id.startsWith(IMPORT_MAP_PREFIX)) return
-        const pkg = id.slice(IMPORT_MAP_PREFIX.length)
-        // Dynamically discover exports at build time by importing the package.
-        // We generate explicit named re-exports (not `export *`) because CJS
-        // packages like React only expose a default via `export *`, losing
-        // individual named exports (useState, jsx, etc.) that foundations need.
-        try {
-          const mod = await import(pkg)
-          const names = Object.keys(mod).filter(k => k !== '__esModule')
-          const hasDefault = 'default' in mod
-          const named = names.filter(k => k !== 'default')
-          const lines = []
-          if (named.length) {
-            lines.push(`export { ${named.join(', ')} } from '${pkg}'`)
-          }
-          if (hasDefault) {
-            lines.push(`export { default } from '${pkg}'`)
+  // Preload hints for runtime-loaded foundations and extensions.
+  // In runtime mode, foundation JS is loaded via import() and CSS is injected
+  // dynamically in JavaScript — the browser doesn't discover them until JS executes.
+  // These <link> tags let the browser start fetching during HTML parsing.
+  // Shell mode is excluded: URLs come from __DATA__ at serve time (unicloud handles it).
+  if (isRuntimeMode && !isShellMode) {
+    plugins.push({
+      name: 'uniweb:foundation-preload',
+      transformIndexHtml: {
+        order: 'post',
+        handler() {
+          const tags = []
+
+          // Foundation JS modulepreload
+          if (foundationConfig.url) {
+            tags.push({
+              tag: 'link',
+              attrs: { rel: 'modulepreload', href: foundationConfig.url },
+              injectTo: 'head',
+            })
           }
-          return lines.join('\n') || `export {}`
-        } catch {
-          // Fallback: generic re-export (may not preserve named exports for CJS)
-          return `export * from '${pkg}'`
-        }
-      },
 
-      // Emit deterministic chunks for each external (production only).
-      // preserveSignature: 'exports-only' tells Rollup to preserve the original
-      // export names (useState, jsx, etc.) instead of mangling them.
-      // In dev mode, Vite's transformRequest() resolves bare specifiers instead.
-      buildStart() {
-        if (!isBuild) return
-        for (const ext of IMPORT_MAP_EXTERNALS) {
-          this.emitFile({
-            type: 'chunk',
-            id: `${IMPORT_MAP_PREFIX}${ext}`,
-            fileName: `_importmap/${ext.replace(/\//g, '-')}.js`,
-            preserveSignature: 'exports-only'
-          })
-        }
-      },
+          // Foundation CSS — injected as a real <link> so the browser fetches it
+          // during HTML parsing instead of waiting for loadFoundationCSS() in JS.
+          // The runtime's dynamic <link> deduplicates (same URL, already cached).
+          if (foundationConfig.cssUrl) {
+            tags.push({
+              tag: 'link',
+              attrs: { rel: 'stylesheet', href: foundationConfig.cssUrl },
+              injectTo: 'head',
+            })
+          }
 
-      // Inject the import map into the HTML (production only).
-      // In dev mode, Vite's transformRequest() handles bare specifier resolution.
-      transformIndexHtml: {
-        order: 'pre',
-        handler(html) {
-          if (!isBuild) return html
-          const basePath = base || '/'
-          const imports = {}
-          for (const ext of IMPORT_MAP_EXTERNALS) {
-            imports[ext] = `${basePath}_importmap/${ext.replace(/\//g, '-')}.js`
+          // Extension JS modulepreload (CSS left to runtime — we can't reliably
+          // derive CSS URLs for all extension formats)
+          const extensions = siteConfig.extensions || []
+          for (const ext of extensions) {
+            const url = typeof ext === 'string' ? ext : ext?.url
+            if (url) {
+              tags.push({
+                tag: 'link',
+                attrs: { rel: 'modulepreload', href: url },
+                injectTo: 'head',
+              })
+            }
           }
-          const importMap = JSON.stringify({ imports }, null, 2)
-          const script = `    <script type="importmap">\n${importMap}\n    </script>\n`
-          // Import map must appear before any module scripts
-          return html.replace('<head>', '<head>\n' + script)
-        }
-      }
-    }
-  })() : null
 
-  if (importMapPlugin) plugins.push(importMapPlugin)
+          return tags
+        },
+      },
+    })
+  }
 
   // Build foundation config for runtime
   const foundationConfig = {

package/src/site/content-collector.js

@@ -1425,6 +1425,14 @@ async function collectPagesRecursive(dirPath, parentRoute, siteRoot, orderConfig
           const { page, assetCollection: pageAssets, iconCollection: pageIcons } = result
           assetCollection = mergeAssetCollections(assetCollection, pageAssets)
           iconCollection = mergeIconCollections(iconCollection, pageIcons)
+
+          // Modern pattern: blog/index/ (isIndex) inherits the container's fetch config
+          // when it has no fetch of its own. Without this, EntityStore can't find the
+          // fetch config for sections on the index page (page.parent is null for /blog).
+          if (isIndex && !page.fetch && parentFetch) {
+            page.fetch = parentFetch
+          }
+
           pages.push(page)
 
           // Recurse into subdirectories (page mode)
@@ -1477,16 +1485,17 @@ async function collectPagesRecursive(dirPath, parentRoute, siteRoot, orderConfig
             changefreq: dirConfig.seo?.changefreq || null,
             priority: dirConfig.seo?.priority || null
           },
-          fetch: null,
+          fetch: parseFetchConfig(dirConfig.fetch) || null,
           sections: [],
           order: typeof dirConfig.order === 'number' ? dirConfig.order : undefined
         }
 
         pages.push(containerPage)
 
-        // Recurse in folder mode
+        // Recurse in folder mode — pass container's own fetch config (or fall back to parent's)
         const childDirPath = mounts?.get(entry) || entryPath
-        const subResult = await collectPagesRecursive(childDirPath, containerRoute, siteRoot, childOrderConfig, parentFetch, versionContext, 'pages', null, effectiveLayout)
+        const containerFetch = containerPage.fetch || parentFetch
+        const subResult = await collectPagesRecursive(childDirPath, containerRoute, siteRoot, childOrderConfig, containerFetch, versionContext, 'pages', null, effectiveLayout)
         pages.push(...subResult.pages)
         assetCollection = mergeAssetCollections(assetCollection, subResult.assetCollection)
         iconCollection = mergeIconCollections(iconCollection, subResult.iconCollection)
@@ -1595,6 +1604,13 @@ async function collectPagesRecursive(dirPath, parentRoute, siteRoot, orderConfig
         assetCollection = mergeAssetCollections(assetCollection, pageAssets)
         iconCollection = mergeIconCollections(iconCollection, pageIcons)
 
+        // Modern pattern: articles/index/ (isIndex) inherits the container's fetch config
+        // when it has no fetch of its own. Without this, EntityStore can't find the
+        // fetch config for sections on the index page.
+        if (isIndex && !page.fetch && parentFetch) {
+          page.fetch = parentFetch
+        }
+
         // Handle 404 page - only at root level
         if (parentRoute === '/' && entry === '404') {
           notFound = page

package/src/site/data-fetcher.js

@@ -225,6 +225,18 @@ export function parseFetchConfig(fetch) {
   // Full config object
   if (typeof fetch !== 'object') return null
 
+  // Inherit-merge config: { inherit: true, detail: false, limit: 3 }
+  // No URL — merges with the parent fetch config at runtime; only carries override props.
+  if (fetch.inherit === true) {
+    return {
+      inherit: true,
+      ...(fetch.detail !== undefined ? { detail: fetch.detail } : {}),
+      ...(fetch.limit !== undefined ? { limit: fetch.limit } : {}),
+      ...(fetch.sort !== undefined ? { sort: fetch.sort } : {}),
+      ...(fetch.filter !== undefined ? { filter: fetch.filter } : {}),
+    }
+  }
+
   // Collection reference: { collection: 'articles', limit: 3 }
   if (fetch.collection) {
     return {

package/src/vite-foundation-plugin.js

@@ -34,6 +34,133 @@ async function buildSchemaWithPreviews(srcDir, outDir, isProduction, sectionPath
   return schemaWithImages
 }
 
+/**
+ * Module-level guard to prevent recursive SSR bundle builds.
+ * When buildSSRBundle calls esbuild, it should not re-trigger
+ * the foundation plugin's writeBundle hook.
+ */
+let _buildingSSRBundle = false
+
+/**
+ * Build a self-contained ESM bundle for edge SSR (Dynamic Workers).
+ *
+ * Produces foundation.ssr.js — a single ESM file with React, ReactDOM/server,
+ * @uniweb/core, and the foundation components all inlined. No external imports.
+ *
+ * This bundle is loaded into a Cloudflare Dynamic Worker isolate at request time
+ * via env.LOADER.get(). The isolate caches the bundle per foundation version.
+ *
+ * @param {string} outDir - Path to dist/ directory containing foundation.js
+ */
+async function buildSSRBundle(outDir) {
+  if (_buildingSSRBundle) return
+  _buildingSSRBundle = true
+
+  const entryPath = join(outDir, 'foundation.js')
+  try {
+    const { build: esbuild } = await import('esbuild')
+    const { statSync } = await import('node:fs')
+
+    // Collect all node_modules directories up the tree (pnpm hoists to workspace root)
+    const { existsSync } = await import('node:fs')
+    let searchDir = resolve(outDir, '..')
+    let nodePaths = []
+    for (let i = 0; i < 10; i++) {
+      const candidate = join(searchDir, 'node_modules')
+      if (existsSync(candidate)) {
+        nodePaths.push(candidate)
+      }
+      const parent = resolve(searchDir, '..')
+      if (parent === searchDir) break
+      searchDir = parent
+    }
+
+    // Resolve workspace packages that esbuild can't find via node_modules
+    // (pnpm workspace symlinks aren't in node_modules for the foundation project)
+    const { createRequire } = await import('node:module')
+    const pluginRequire = createRequire(import.meta.url)
+    let runtimeSSRPath
+    try {
+      runtimeSSRPath = pluginRequire.resolve('@uniweb/runtime/ssr')
+    } catch {
+      // Fallback: try to find it relative to the workspace root
+      for (const np of nodePaths) {
+        const candidate = join(np, '@uniweb', 'runtime', 'dist', 'ssr.js')
+        if (existsSync(candidate)) {
+          runtimeSSRPath = candidate
+          break
+        }
+      }
+    }
+
+    // Build a self-contained ESM bundle including:
+    // - Foundation components (from the just-built ESM output)
+    // - React + ReactDOM/server (browser version, no Node.js built-ins)
+    // - @uniweb/core (Website, Page, Block classes)
+    // - @uniweb/runtime/ssr (initPrerender, renderPage, injectPageContent)
+    // - @uniweb/theming (buildSectionOverrides, used by runtime/ssr)
+    //
+    // All in a single file so the Dynamic Worker isolate has one React instance.
+    const ssrExports = runtimeSSRPath
+      ? `export { initPrerender, renderPage, injectPageContent, prefetchIcons } from "${runtimeSSRPath.replace(/\\/g, '/')}";`
+      : ''
+
+    // Resolve React to a single package directory to avoid duplicate instances
+    // (foundation.js and runtime/ssr may resolve to different copies)
+    const { dirname } = await import('node:path')
+    let reactDir
+    try {
+      reactDir = dirname(pluginRequire.resolve('react/package.json'))
+    } catch {
+      // Fall back to nodePaths resolution
+    }
+    const alias = {}
+    if (reactDir) {
+      alias['react'] = reactDir
+      // Force react-dom/server imports to the browser version (no Node.js built-ins)
+      const reactDomDir = dirname(pluginRequire.resolve('react-dom/package.json'))
+      alias['react-dom'] = reactDomDir
+      alias['react-dom/server'] = join(reactDomDir, 'server.browser.js')
+    }
+
+    const foundationPath = entryPath.replace(/\\/g, '/')
+    await esbuild({
+      stdin: {
+        contents: [
+          // Foundation components (named + default export)
+          `export * from "${foundationPath}";`,
+          `export { default } from "${foundationPath}";`,
+          // React SSR
+          `export { renderToString } from "react-dom/server.browser";`,
+          `export { createElement } from "react";`,
+          // Runtime SSR functions (initPrerender, renderPage, etc.)
+          ssrExports,
+        ].join('\n'),
+        resolveDir: outDir,
+        loader: 'js',
+      },
+      bundle: true,
+      format: 'esm',
+      platform: 'browser',
+      outfile: join(outDir, 'foundation.ssr.js'),
+      minify: false,
+      external: [],
+      nodePaths,
+      alias,
+      conditions: ['browser', 'module'],
+      logLevel: 'warning',
+    })
+
+    const ssrFile = join(outDir, 'foundation.ssr.js')
+    const size = (statSync(ssrFile).size / 1024).toFixed(1)
+    console.log(`Generated foundation.ssr.js (${size} KB)`)
+  } catch (err) {
+    console.warn(`Warning: SSR bundle build failed: ${err.message}`)
+  } finally {
+    _buildingSSRBundle = false
+  }
+}
+
 /**
  * Vite plugin for foundation builds
  */
@@ -69,6 +196,9 @@ export function foundationBuildPlugin(options = {}) {
     },
 
     async writeBundle() {
+      // Skip if this is a recursive call from buildSSRBundle
+      if (_buildingSSRBundle) return
+
       // After bundle is written, generate schema.json in meta folder
       const outDir = resolve(resolvedOutDir)
       const metaDir = join(outDir, 'meta')
@@ -87,6 +217,9 @@ export function foundationBuildPlugin(options = {}) {
       await writeFile(schemaPath, JSON.stringify(schema, null, 2), 'utf-8')
 
       console.log(`Generated meta/schema.json with ${Object.keys(schema).length - 1} components`)
+
+      // Build self-contained SSR bundle for edge rendering (Dynamic Workers)
+      await buildSSRBundle(outDir)
     },
   }
 }