orga-build 0.9.0 → 0.10.0

package/lib/plugin.js

@@ -1,40 +1,45 @@
-import fs from 'node:fs/promises'
 import { createRequire } from 'node:module'
 import path from 'node:path'
 import { fileURLToPath } from 'node:url'
 import react from '@vitejs/plugin-react'
-import { createServerModuleRunner } from 'vite'
-import { resolveEndpointResponse } from './endpoint.js'
+import { devSsrPlugin } from './dev-ssr.js'
+import { htmlShellPlugin } from './html.js'
+import { islandPlugin } from './island.js'
 import { setupOrga } from './orga.js'
-import { escapeHtml } from './util.js'
+import { prerenderPlugin } from './prerender.js'
 import { pluginFactory } from './vite.js'
 
 const ssrEntry = fileURLToPath(new URL('./ssr.jsx', import.meta.url))
+/**
+ * Prefix of emitted asset paths in server-rendered markup, replaced per page
+ * while prerendering (see `prerender.js`).
+ */
+export const assetUrlMarker = '/@orga-build/asset/'
 
 const require = createRequire(import.meta.url)
-const defaultIndexHtml = fileURLToPath(new URL('./index.html', import.meta.url))
 /**
- * Alias map for React and wouter to ensure consistent resolution
+ * Alias map for React to ensure a single copy is bundled
  */
 export const alias = {
 	react: path.dirname(require.resolve('react/package.json')),
-	'react-dom': path.dirname(require.resolve('react-dom/package.json')),
-	wouter: path.dirname(require.resolve('wouter'))
+	'react-dom': path.dirname(require.resolve('react-dom/package.json'))
 }
 
 /**
  * @typedef {Object} OrgaBuildPluginOptions
  * @property {string} root - Root directory for content files
- * @property {string | undefined} [outDir] - Output directory (excluded from file discovery)
+ * @property {string | undefined} [outDir] - Output directory (default: Vite's `build.outDir`)
  * @property {string|string[]} [containerClass] - CSS class(es) to wrap rendered content
- * @property {string[]} [styles] - Global stylesheet URLs to import/inject
+ * @property {string[]} [styles] - Global stylesheet URLs to link from the HTML shell
  * @property {import('unified').PluggableList} [rehypePlugins] - Extra rehype plugins appended to orga-build defaults
  * @property {string[]} [exclude] - Glob patterns for files to exclude from content scanning
+ * @property {string | undefined} [site] - Absolute URL the site is served from, e.g. `https://example.com`
  */
 
 /**
- * Creates the canonical orga-build plugin preset.
- * This is the single composition path used by both dev and build.
+ * Creates the orga-build plugin preset: everything needed for `vite` (dev SSR)
+ * and `vite build` (static site) to work, used by the CLI and usable directly
+ * in a `vite.config.js`.
  *
  * @param {OrgaBuildPluginOptions} options
  * @returns {import('vite').PluginOption[]}
@@ -45,198 +50,143 @@ export function orgaBuildPlugin({
 	containerClass = [],
 	styles = [],
 	rehypePlugins = [],
-	exclude = []
+	exclude = [],
+	site
 }) {
+	// Virtual modules import content files by path, so it must be absolute.
+	root = path.resolve(root)
+	site = normalizeSite(site)
+	const islands = islandPlugin()
 	return [
+		configPlugin({ root, outDir }),
+		htmlShellPlugin(styles),
+		devSsrPlugin(site),
+		prerenderPlugin(islands, site),
+		islands,
 		setupOrga({ containerClass, root, rehypePlugins }),
 		react(),
-		pluginFactory({ dir: root, outDir, styles, exclude })
+		pluginFactory({ dir: root, exclude, site })
 	]
 }
 
 /**
- * Creates the full Vite config options for orga-build.
- * Includes plugins, resolve aliases, and other shared config.
- *
- * @param {OrgaBuildPluginOptions & { outDir?: string, vitePlugins?: import('vite').PluginOption[], includeFallbackHtml?: boolean, projectRoot?: string }} options
- * @returns {{ plugins: import('vite').PluginOption[], resolve: { alias: typeof alias } }}
+ * Without a trailing slash, so `site + page.slug` is a page's URL.
+ * @param {string | undefined} site
  */
-export function createOrgaBuildConfig({
-	root,
-	outDir,
-	containerClass = [],
-	styles = [],
-	rehypePlugins = [],
-	vitePlugins = [],
-	includeFallbackHtml = false,
-	projectRoot = process.cwd(),
-	exclude = []
-}) {
-	const plugins = [
-		...vitePlugins,
-		...orgaBuildPlugin({
-			root,
-			outDir,
-			containerClass,
-			styles,
-			rehypePlugins,
-			exclude
-		})
-	]
-	if (includeFallbackHtml) {
-		// HTML fallback must be first so it can handle HTML navigation requests
-		// before runtime plugins (e.g. Cloudflare) potentially return 404.
-		plugins.unshift(htmlFallbackPlugin(projectRoot, styles))
-	}
-	return {
-		plugins,
-		resolve: { alias }
+function normalizeSite(site) {
+	if (site === undefined) return
+	// `localhost:3000` parses too, as a URL with the scheme `localhost:`.
+	const url = URL.canParse(site) ? new URL(site) : undefined
+	if (url?.protocol !== 'http:' && url?.protocol !== 'https:') {
+		throw new Error(
+			`orga-build: "site" must be an absolute http(s) URL, e.g. "https://example.com", got "${site}"`
+		)
 	}
+	return url.href.replace(/\/+$/, '')
 }
 
 /**
- * Checks if a user-provided index.html exists in the project root.
+ * Creates the full Vite config options for orga-build.
  *
- * @param {string} root - Project root directory
- * @returns {Promise<boolean>}
+ * @param {OrgaBuildPluginOptions & { vitePlugins?: import('vite').PluginOption[] }} options
+ * @returns {{ plugins: import('vite').PluginOption[] }}
  */
-async function hasUserIndexHtml(root) {
-	try {
-		await fs.access(path.join(root, 'index.html'), fs.constants.F_OK)
-		return true
-	} catch {
-		return false
+export function createOrgaBuildConfig({ vitePlugins = [], ...options }) {
+	return {
+		plugins: [...vitePlugins, ...orgaBuildPlugin(options)]
 	}
 }
 
 /**
- * Creates an HTML serving plugin that handles index.html for dev mode.
- *
- * This plugin performs per-request SSR in dev mode (matching Astro/SvelteKit behaviour):
- * - SSR-renders each page on every request using Vite's server module runner
- * - Injects rendered content and page metadata (%orga.*% placeholders) into the template
- * - Falls back to the shell HTML for unknown routes (client-side router handles 404)
- * - Only handles GET/HEAD requests that accept HTML
- * - Does not intercept asset requests
- *
- * @param {string} projectRoot - Project root directory (where orga.config.js lives)
- * @param {string[]} [styles]
+ * @param {Object} options
+ * @param {string} options.root - Content root
+ * @param {string | undefined} options.outDir
  * @returns {import('vite').Plugin}
  */
-export function htmlFallbackPlugin(projectRoot, styles = []) {
+function configPlugin({ root, outDir }) {
 	return {
-		name: 'orga-build:html-fallback',
-
-		async configureServer(server) {
-			// Determine which index.html to use at startup
-			// Look for user's index.html in project root (where orga.config.js lives)
-			const userIndexPath = path.join(projectRoot, 'index.html')
-			const userHasIndex = await hasUserIndexHtml(projectRoot)
-			const indexHtmlPath = userHasIndex ? userIndexPath : defaultIndexHtml
-
-			// CJS compatibility here depends on Vite externalizing bare-specifier deps
-			// (e.g. react/*) to native Node import(). If aliases rewrite specifiers
-			// to absolute paths, modules can be inlined and evaluated without CJS globals.
-			const runner = createServerModuleRunner(server.environments.ssr)
-
-			server.middlewares.use(async (req, res, next) => {
-				// Only handle GET/HEAD requests
-				if (req.method !== 'GET' && req.method !== 'HEAD') {
-					return next()
-				}
-
-				const url = req.url || '/'
-				const pathname = url.split('?')[0]
-
-				// Endpoint routes are handled first and bypass HTML fallback.
-				try {
-					const { endpoints } = await runner.import(ssrEntry)
-					const endpointModule = endpoints?.[pathname]
-					if (endpointModule) {
-						const ctx = {
-							url: new URL(url, `http://${req.headers.host || 'localhost'}`),
-							params: {},
-							mode: /** @type {'dev'} */ ('dev'),
-							route: { route: pathname }
+		name: 'orga-build:config',
+		config(config, { command }) {
+			const clientOutDir = outDir ?? config.build?.outDir ?? 'dist'
+			const isBuild = command === 'build'
+			const contentDir = path
+				.relative(path.resolve(config.root ?? ''), path.resolve(root))
+				.split(path.sep)
+				.join('/')
+			return {
+				// HTML is served by orga-build:dev-ssr, not Vite's SPA fallback.
+				appType: 'custom',
+				// Asset URLs in server-rendered markup are resolved per page while
+				// prerendering, so a relative `base` works for nested pages. Left
+				// alone when the user renders URLs themselves.
+				experimental: config.experimental?.renderBuiltUrl
+					? {}
+					: {
+							renderBuiltUrl(filename, { hostType, ssr }) {
+								if (ssr && hostType === 'js') return assetUrlMarker + filename
+							}
+						},
+				// Make `vite build` build every environment through buildApp.
+				builder: {},
+				// `resolve.alias` is global, not per-environment, so it is only set
+				// for build. In dev it would also reach the SSR module runner: the
+				// aliases turn bare specifiers (e.g. 'react') into absolute paths,
+				// which bypasses Vite's externalization and evaluates CJS packages
+				// inline, without 'module'/'require' globals.
+				resolve: isBuild ? { alias } : {},
+				build: {
+					outDir: clientOutDir,
+					// Also tells Vite to stop watching outDir in dev.
+					emptyOutDir: true,
+					cssCodeSplit: false
+				},
+				server: { forwardConsole: true },
+				environments: {
+					client: {
+						input: 'index.html',
+						// Islands are extra client chunks; prerendering reads their
+						// hashed names from the manifest.
+						build: { manifest: true },
+						optimizeDeps: {
+							// Scan pages, layouts and components up front so their deps
+							// are pre-bundled at startup instead of triggering a reload
+							// when first visited.
+							entries: [
+								'**/*.html',
+								path.posix.join(contentDir, '**/*.{jsx,tsx}')
+							],
+							// The island runtime lives in orga-build itself (in
+							// node_modules once installed), which the scanner never
+							// crawls. Pre-bundle its CJS deps explicitly or the browser
+							// gets raw CommonJS.
+							include: ['react', 'react-dom/client']
 						}
-
-						const response = await resolveEndpointResponse(
-							endpointModule,
-							ctx,
-							req.method
-						)
-						res.statusCode = response.status
-						response.headers.forEach((headerValue, headerName) => {
-							res.setHeader(headerName, headerValue)
-						})
-						if (req.method === 'HEAD') {
-							res.end()
-							return
+					},
+					ssr: {
+						input: ssrEntry,
+						// The built SSR bundle is self-contained so it can be imported
+						// from its outDir, which sits outside the site's outDir because
+						// it must survive the client build.
+						resolve: isBuild ? { noExternal: true } : {},
+						build: {
+							outDir: path.join(
+								path.resolve(config.root ?? ''),
+								'node_modules/.orga-build/ssr'
+							),
+							// Pages live only in this graph now, so their images and CSS
+							// must be emitted here; prerendering copies them to the site.
+							emitAssets: true,
+							minify: false,
+							rolldownOptions: {
+								output: {
+									entryFileNames: '[name].mjs',
+									chunkFileNames: '[name]-[hash].mjs'
+								}
+							}
 						}
-						const bytes = Buffer.from(await response.arrayBuffer())
-						res.end(bytes)
-						return
 					}
-				} catch (e) {
-					next(e)
-					return
-				}
-
-				// Only handle browser-like navigation requests.
-				// Don't match generic */* accepts to avoid hijacking API requests.
-				const accept = req.headers.accept || ''
-				if (!accept.includes('text/html')) {
-					return next()
-				}
-
-				// Don't intercept asset requests (files with extensions)
-				if (pathname !== '/' && /\.\w+$/.test(pathname)) {
-					return next()
-				}
-
-				try {
-					// Import via the runner on each request — the module graph handles
-					// HMR invalidation so stale modules are never served.
-					const { render, pages } = await runner.import(ssrEntry)
-					const content = render(pathname)
-
-					let html = await fs.readFile(indexHtmlPath, 'utf-8')
-					html = await server.transformIndexHtml(url, html)
-
-					const uniqueCssUrls = [...new Set(styles)]
-					if (uniqueCssUrls.length > 0) {
-						const cssLinks = uniqueCssUrls
-							.map((u) => `<link rel="stylesheet" href="${escapeHtml(u)}">`)
-							.join('')
-						html = html.replace('</head>', `${cssLinks}</head>`)
-					}
-
-					if (content) {
-						const ssr = { routePath: pathname }
-						html = html.replace(
-							'<div id="root"></div>',
-							`<script>window._ssr=${JSON.stringify(ssr)};</script><div id="root">${content}</div>`
-						)
-					}
-
-					// Replace %orga.*% placeholders with page metadata
-					const page = pages[pathname]
-					if (page) {
-						html = html.replace(/%orga\.(\w+)%/g, (_, key) => {
-							const value = page[key] ?? ''
-							return escapeHtml(String(value))
-						})
-					}
-					// Strip any remaining unresolved placeholders (unknown route)
-					html = html.replace(/%orga\.\w+%/g, '')
-
-					res.statusCode = 200
-					res.setHeader('Content-Type', 'text/html')
-					res.end(html)
-				} catch (e) {
-					next(e)
 				}
-			})
+			}
 		}
 	}
 }

package/lib/prerender.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Turns `vite build` into a static site build: builds the SSR and client
+ * environments, then renders every page and endpoint into the client outDir.
+ *
+ * @param {import('vite').Plugin} islands - The island plugin, whose `api`
+ *   tells whether the client build ran before islands were discovered
+ * @param {string | undefined} site - Absolute site URL, without a trailing slash
+ * @returns {import('vite').Plugin}
+ */
+export function prerenderPlugin(islands: import("vite").Plugin, site: string | undefined): import("vite").Plugin;
+//# sourceMappingURL=prerender.d.ts.map

package/lib/prerender.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prerender.d.ts","sourceRoot":"","sources":["prerender.js"],"names":[],"mappings":"AAUA;;;;;;;;GAQG;AACH,yCALW,OAAO,MAAM,EAAE,MAAM,QAErB,MAAM,GAAG,SAAS,GAChB,OAAO,MAAM,EAAE,MAAM,CAsBjC"}

package/lib/prerender.js

@@ -0,0 +1,184 @@
+import fs from 'node:fs/promises'
+import path from 'node:path'
+import { pathToFileURL } from 'node:url'
+import { normalizePath } from 'vite'
+import { resolveEndpointResponse } from './endpoint.js'
+import { ensureDir } from './fs.js'
+import { renderPageHtml } from './html.js'
+import { clientRuntime } from './island.js'
+import { assetUrlMarker } from './plugin.js'
+
+/**
+ * Turns `vite build` into a static site build: builds the SSR and client
+ * environments, then renders every page and endpoint into the client outDir.
+ *
+ * @param {import('vite').Plugin} islands - The island plugin, whose `api`
+ *   tells whether the client build ran before islands were discovered
+ * @param {string | undefined} site - Absolute site URL, without a trailing slash
+ * @returns {import('vite').Plugin}
+ */
+export function prerenderPlugin(islands, site) {
+	return {
+		name: 'orga-build:prerender',
+
+		buildApp: {
+			// Run after any configured `builder.buildApp`: a client build empties
+			// outDir, so prerendered files must be written last.
+			order: 'post',
+			async handler(builder) {
+				const { client, ssr } = builder.environments
+				// Islands are discovered while building `ssr`, so it goes first. A
+				// client built earlier (e.g. by another plugin's buildApp) lacks them.
+				if (!ssr.isBuilt) await builder.build(ssr)
+				if (!client.isBuilt || islands.api?.clientIsStale) {
+					await builder.build(client)
+				}
+				await prerender(client, ssr, islands, site)
+			}
+		}
+	}
+}
+
+/**
+ * @param {import('vite').BuildEnvironment} client
+ * @param {import('vite').BuildEnvironment} ssr
+ * @param {import('vite').Plugin} islands - Its `api.ssrAssets` lists the files the SSR build emitted
+ * @param {string | undefined} site
+ */
+async function prerender(client, ssr, islands, site) {
+	const outDir = resolveOutDir(client)
+	const ssrOutDir = resolveOutDir(ssr)
+	const { root, base } = client.config
+
+	// Images and CSS imported by pages are emitted by the SSR build next to its
+	// bundle: move them into the site and link the CSS (one file, see
+	// `cssCodeSplit`).
+	/** @type {string[]} */
+	const emitted = [.../** @type {Set<string>} */ (islands.api?.ssrAssets ?? [])]
+	await Promise.all(
+		emitted.map(async (file) => {
+			await ensureDir(path.dirname(path.join(outDir, file)))
+			await fs.copyFile(path.join(ssrOutDir, file), path.join(outDir, file))
+		})
+	)
+	const styles = emitted.filter((file) => file.endsWith('.css'))
+
+	/**
+	 * URL of a file in outDir from a page `depth` directories deep. With a
+	 * relative `base`, URLs are relative to the page's directory.
+	 * @param {number} depth
+	 */
+	const urlAt =
+		(depth) =>
+		/** @param {string} file */
+		(file) =>
+			base === './'
+				? `${depth ? '../'.repeat(depth) : './'}${file}`
+				: base + file
+
+	// Cache-bust so repeated builds in one process load the fresh bundle.
+	const ssrModuleUrl = pathToFileURL(path.join(ssrOutDir, 'ssr.mjs'))
+	ssrModuleUrl.search = `t=${Date.now()}`
+	const { render, pages, endpoints = {} } = await import(ssrModuleUrl.href)
+
+	// Vite has processed index.html into the shell: stylesheets are already
+	// injected with their hashed names.
+	const shellPath = path.join(outDir, 'index.html')
+	const template = await fs.readFile(shellPath, 'utf-8')
+	if (!pages['/']) await fs.rm(shellPath)
+
+	// Islands are built as extra client chunks; the manifest has their names.
+	/** @type {Record<string, { file: string }>} */
+	const manifest = JSON.parse(
+		await fs.readFile(path.join(outDir, '.vite/manifest.json'), 'utf-8')
+	)
+	const runtimeSrc = normalizePath(path.relative(root, clientRuntime))
+
+	await Promise.all(
+		Object.keys(pages).map(async (pathname) => {
+			const toUrl = urlAt(pathname.split('/').filter(Boolean).length)
+			/** @param {string} src */
+			const url = (src) => {
+				const file = manifest[src]?.file
+				if (!file) {
+					throw new Error(
+						`island "${src}" is missing from the client build: the client environment must be built after ssr`
+					)
+				}
+				return toUrl(file)
+			}
+			const html = renderPageHtml(rebaseRelativeUrls(template, pathname), {
+				// Emitted assets are marked in the markup (see `renderBuiltUrl`).
+				content: render(pathname, url)?.replaceAll(assetUrlMarker, toUrl('')),
+				page: pages[pathname],
+				islandScript: manifest[runtimeSrc] && url(runtimeSrc),
+				styles: styles.map(toUrl)
+			})
+			const writePath = path.join(
+				outDir,
+				pathname.replace(/^\//, ''),
+				'index.html'
+			)
+			await ensureDir(path.dirname(writePath))
+			await fs.writeFile(writePath, html)
+		})
+	)
+
+	await Promise.all(
+		Object.keys(endpoints).map(async (route) => {
+			const ctx = {
+				url: new URL((site ?? 'http://localhost') + route),
+				params: {},
+				mode: /** @type {'build'} */ ('build'),
+				route: { route },
+				site
+			}
+
+			const response = await resolveEndpointResponse(
+				endpoints[route],
+				ctx,
+				'GET'
+			)
+			if (response.status < 200 || response.status >= 300) {
+				throw new Error(
+					`Endpoint route "${route}" returned non-2xx status during build: ${response.status}`
+				)
+			}
+
+			// Responses may carry emitted asset URLs too (see `renderBuiltUrl`).
+			// The marker is ASCII, so the substitution is done on a byte-preserving
+			// latin1 view: any charset survives, and untouched bodies stay as is.
+			let body = Buffer.from(await response.arrayBuffer())
+			if (body.includes(assetUrlMarker)) {
+				const toUrl = urlAt(route.split('/').filter(Boolean).length - 1)
+				body = Buffer.from(
+					body.toString('latin1').replaceAll(assetUrlMarker, toUrl('')),
+					'latin1'
+				)
+			}
+			const writePath = path.join(outDir, route.replace(/^\//, ''))
+			await ensureDir(path.dirname(writePath))
+			await fs.writeFile(writePath, body)
+		})
+	)
+}
+
+/**
+ * With a relative `base`, Vite writes the shell's URLs relative to the root
+ * `index.html` (`./assets/…`). Rebase them for pages in nested directories.
+ *
+ * @param {string} html
+ * @param {string} pathname
+ */
+function rebaseRelativeUrls(html, pathname) {
+	const depth = pathname.split('/').filter(Boolean).length
+	if (!depth) return html
+	return html.replace(/(\s(?:src|href)=["'])\.\//g, `$1${'../'.repeat(depth)}`)
+}
+
+/**
+ * @param {import('vite').BuildEnvironment} environment
+ */
+function resolveOutDir(environment) {
+	return path.resolve(environment.config.root, environment.config.build.outDir)
+}

package/lib/serve.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"serve.d.ts","sourceRoot":"","sources":["serve.js"],"names":[],"mappings":"AAIA;;;;;;GAMG;AACH,8BAJW,OAAO,aAAa,EAAE,MAAM,SAC5B,MAAM,gBACN,MAAM,iBAuChB"}
+{"version":3,"file":"serve.d.ts","sourceRoot":"","sources":["serve.js"],"names":[],"mappings":"AAGA;;;;;;GAMG;AACH,8BAJW,OAAO,aAAa,EAAE,MAAM,SAC5B,MAAM,gBACN,MAAM,iBAsBhB"}

package/lib/serve.js

@@ -1,6 +1,5 @@
-import path from 'node:path'
 import { createServer } from 'vite'
-import { alias, createOrgaBuildConfig } from './plugin.js'
+import { createOrgaBuildConfig } from './plugin.js'
 
 /**
  * Start the development server using native Vite.
@@ -17,31 +16,14 @@ export async function serve(config, port = 3000, projectRoot = process.cwd()) {
 		styles: config.styles ?? [],
 		rehypePlugins: config.rehypePlugins ?? [],
 		vitePlugins: config.vitePlugins,
-		includeFallbackHtml: true,
-		projectRoot,
-		exclude: config.exclude ?? []
+		exclude: config.exclude ?? [],
+		site: config.site
 	})
 
 	const server = await createServer({
+		root: projectRoot,
 		plugins,
-		appType: 'custom',
-		// Aliases are scoped to the client environment only.
-		// The SSR environment must NOT have these aliases: they convert bare specifiers
-		// (e.g. 'react') into absolute paths, which bypasses Vite's fetchModule
-		// externalization branch and causes CJS packages to be evaluated inline by
-		// ESModulesEvaluator (which has no 'module'/'require' globals).
-		environments: {
-			client: {
-				resolve: /** @type {any} */ ({ alias })
-			}
-		},
-		server: {
-			port,
-			strictPort: false,
-			watch: {
-				ignored: [`${path.resolve(config.outDir)}/**`]
-			}
-		}
+		server: { port, strictPort: false }
 	})
 
 	await server.listen()

package/lib/ssr.jsx

@@ -1,26 +1,21 @@
 import { renderToString } from 'react-dom/server'
-import { Router } from 'wouter'
 import endpoints from '/@orga-build/endpoints'
 import pages from '/@orga-build/pages'
 import { App } from './app.jsx'
+import { beginPage } from './island.jsx'
 
 export { pages }
 export { endpoints }
 
 /**
+ * Render the page at `url` to static HTML.
+ *
  * @param {string} url
+ * @param {(src: string) => string} resolveIslandUrl - Maps an island's source
+ *   path (relative to the Vite root) to the URL the browser imports it from
  */
-export function render(url) {
-	const page = pages[url]
-	if (!page) {
-		console.log(`no page found for ${url}`)
-		return
-	}
-	const ssrContext = {}
-	console.log(`rendering ${url}`)
-	return renderToString(
-		<Router ssrPath={url} ssrContext={ssrContext}>
-			<App />
-		</Router>
-	)
+export function render(url, resolveIslandUrl) {
+	if (!pages[url]) return
+	beginPage(resolveIslandUrl)
+	return renderToString(<App path={url} />)
 }