rhonojs 0.1.1 → 0.1.3

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "rhonojs",
-	"version": "0.1.1",
+	"version": "0.1.3",
 	"description": "Reactive Web app server focusing on MPAs with a simple server route & browser build api...uses Hono, ESBuild, rmemo, & ctx-core",
 	"keywords": [
 		"reactive",
@@ -54,6 +54,13 @@
 		},
 		"./package.json": "./package.json"
 	},
+	"scripts": {
+		"build": ":",
+		"clean": ":",
+		"exec": "$@",
+		"test": "bun run test:unit",
+		"test:unit": "bun -c node_modules/uvu/bin.js . '\\.test\\.(ts|js)$'"
+	},
 	"dependencies": {
 		"ctx-core": "*",
 		"hono": "^4.0.0",
@@ -62,5 +69,10 @@
 	"peerDependencies": {
 		"esbuild": "^0.27.3"
 	},
+	"devDependencies": {
+		"bun-types": "^1.3.10",
+		"typescript": "next",
+		"uvu": "^0.5.6"
+	},
 	"sideEffects": false
 }

package/server/app/index.js

@@ -127,7 +127,7 @@ export async function app__attach(app) {
 					}
 				}
 				for (const middleware of middleware_a1) {
-					if (middleware instanceof Hono) {
+					if (middleware instanceof Hono || (middleware && typeof middleware.fetch === 'function' && typeof middleware.route === 'function')) {
 						app.route('/', middleware)
 					} else {
 						app.use(middleware)

package/server/app/index.test.ts

@@ -0,0 +1,88 @@
+import { Hono } from 'hono'
+import { app_ctx, app_path__set, ctx_, cwd__set, server__metafile__set } from 'rebuildjs/server'
+import { test } from 'uvu'
+import { equal, throws } from 'uvu/assert'
+import { server__metafile0 } from '../../_fixtures/metafile.js'
+import {
+	app$_,
+	app_,
+	app__set,
+	server_entry__output__link__path$_,
+	server_entry__output__link__path_,
+	server_entry__output__path$_,
+	server_entry__output__path_,
+	server_entry__output__relative_path$_,
+	server_entry__output__relative_path_,
+	server_entry__relative_path$_,
+	server_entry__relative_path_
+} from './index.js'
+test.after.each(()=>{
+	app_ctx.s.app.clear()
+})
+test('app', ()=>{
+	equal(app$_(app_ctx)(), undefined)
+	equal(app_(app_ctx), undefined)
+	const app = new Hono()
+	app__set(app_ctx, app)
+	equal(app$_(app_ctx)(), app)
+	equal(app_(app_ctx), app)
+	// @ts-expect-error TS2345
+	throws(()=>app$_(ctx_())())
+	// @ts-expect-error TS2345
+	throws(()=>app_(ctx_()))
+	// @ts-expect-error TS2345
+	throws(()=>app__set(ctx_(), app))
+})
+test('server_entry__relative_path', ()=>{
+	equal(server_entry__relative_path$_(app_ctx)(), 'src/app/index.ts')
+	equal(server_entry__relative_path_(app_ctx), 'src/app/index.ts')
+	cwd__set(app_ctx, '/cwd')
+	app_path__set(app_ctx, '/cwd/src/app2')
+	equal(server_entry__relative_path$_(app_ctx)(), 'src/app2/index.ts')
+	equal(server_entry__relative_path_(app_ctx), 'src/app2/index.ts')
+	// @ts-expect-error TS2345
+	throws(()=>server_entry__relative_path$_(ctx_()))
+	// @ts-expect-error TS2345
+	throws(()=>server_entry__relative_path_(ctx_()))
+})
+test('server_entry__output__relative_path', ()=>{
+	equal(server_entry__output__relative_path$_(app_ctx)(), undefined)
+	equal(server_entry__output__relative_path_(app_ctx), undefined)
+	equal(server_entry__relative_path_(app_ctx), 'src/app/index.ts')
+	server__metafile__set(app_ctx, server__metafile0)
+	equal(server__metafile0.outputs['dist/dev-server/index-OUBLL3JD.js'].entryPoint, 'src/app/index.ts')
+	equal(server_entry__output__relative_path$_(app_ctx)(), 'dist/dev-server/index-OUBLL3JD.js')
+	equal(server_entry__output__relative_path_(app_ctx), 'dist/dev-server/index-OUBLL3JD.js')
+	// @ts-expect-error TS2345
+	throws(()=>server_entry__output__relative_path$_(ctx_()))
+	// @ts-expect-error TS2345
+	throws(()=>server_entry__output__relative_path_(ctx_()))
+})
+test('server_entry__output__path', ()=>{
+	equal(server_entry__output__path$_(app_ctx)(), undefined)
+	equal(server_entry__output__path_(app_ctx), undefined)
+	cwd__set(app_ctx, '/cwd')
+	server__metafile__set(app_ctx, server__metafile0)
+	equal(server_entry__relative_path_(app_ctx), 'src/app/index.ts')
+	equal(server__metafile0.outputs['dist/dev-server/index-OUBLL3JD.js'].entryPoint, 'src/app/index.ts')
+	equal(server_entry__output__path$_(app_ctx)(), '/cwd/dist/dev-server/index-OUBLL3JD.js')
+	equal(server_entry__output__path_(app_ctx), '/cwd/dist/dev-server/index-OUBLL3JD.js')
+	// @ts-expect-error TS2345
+	throws(()=>server_entry__output__path$_(ctx_()))
+	// @ts-expect-error TS2345
+	throws(()=>server_entry__output__path_(ctx_()))
+})
+test('server_entry__output__link__path', ()=>{
+	equal(server_entry__output__link__path$_(app_ctx)(), undefined)
+	equal(server_entry__output__link__path_(app_ctx), undefined)
+	cwd__set(app_ctx, '/cwd')
+	server__metafile__set(app_ctx, server__metafile0)
+	equal(server_entry__relative_path_(app_ctx), 'src/app/index.ts')
+	equal(server_entry__output__link__path$_(app_ctx)(), '/cwd/dist/dev-server/index.js')
+	equal(server_entry__output__link__path_(app_ctx), '/cwd/dist/dev-server/index.js')
+	// @ts-expect-error TS2345
+	throws(()=>server_entry__output__link__path$_(ctx_()))
+	// @ts-expect-error TS2345
+	throws(()=>server_entry__output__link__path_(ctx_()))
+})
+test.run()

package/server/build/index.test.ts

@@ -0,0 +1,84 @@
+import { sleep } from 'ctx-core/function'
+import { ctx_, ns_be_sig_triple_, rmemo__wait } from 'ctx-core/rmemo'
+import {
+	app_ctx,
+	build_id_,
+	build_id__refresh,
+	build_id__set,
+	browser__metafile__set,
+	metafile__build_id_,
+	rebuildjs__build_id__set,
+	rebuildjs__esbuild__build_id__set,
+	rebuildjs__ready__add,
+	server__metafile__set,
+} from 'rebuildjs/server'
+import { test } from 'uvu'
+import { equal, throws } from 'uvu/assert'
+import { browser__metafile0, server__metafile0 } from '../../_fixtures/metafile.js'
+import {
+	rhonojs__build_id$_,
+	rhonojs__build_id_,
+	rhonojs__build_id__set,
+	rhonojs__ready__wait,
+} from './index.js'
+test.after.each(()=>{
+	app_ctx.s.app.clear()
+})
+test('rhonojs__build_id', ()=>{
+	equal(rhonojs__build_id$_(app_ctx)(), undefined)
+	equal(rhonojs__build_id_(app_ctx), undefined)
+	build_id__refresh()
+	equal(typeof build_id_(app_ctx), 'string')
+	rhonojs__build_id__set(app_ctx, build_id_(app_ctx)!)
+	equal(rhonojs__build_id$_(app_ctx)(), build_id_(app_ctx)!)
+	equal(rhonojs__build_id_(app_ctx), build_id_(app_ctx)!)
+	// @ts-expect-error TS2345
+	throws(()=>rhonojs__build_id$_(ctx_()))
+	// @ts-expect-error TS2345
+	throws(()=>rhonojs__build_id_(ctx_()))
+})
+test('rhonojs__ready__wait', async ()=>{
+	let done = false
+	const [
+		plugin__ready$_,
+		,
+		plugin__ready__set
+	] = ns_be_sig_triple_(
+		'app',
+		()=>false)
+	rebuildjs__ready__add(plugin__ready$_)
+	rhonojs__ready__wait().then(()=>done = true)
+	equal(done, false)
+	const build_id = server__metafile0.build_id!
+	build_id__set(app_ctx, build_id)
+	await sleep(0)
+	equal(done, false)
+	server__metafile__set(app_ctx, server__metafile0)
+	await sleep(0)
+	equal(done, false)
+	browser__metafile__set(app_ctx, browser__metafile0)
+	await sleep(0)
+	equal(done, false)
+	rebuildjs__esbuild__build_id__set(app_ctx, build_id)
+	await sleep(0)
+	equal(done, false)
+	rhonojs__build_id__set(app_ctx, build_id)
+	await sleep(0)
+	equal(done, false)
+	plugin__ready__set(app_ctx, true)
+	await sleep(0)
+	equal(done, false)
+	rebuildjs__build_id__set(app_ctx, build_id)
+	await sleep(0)
+	equal(done, true)
+})
+test('rhonojs__ready__wait|timeout', async ()=>{
+	let err:Error|undefined = undefined
+	try {
+		await rhonojs__ready__wait(0)
+	} catch (_err) {
+		err = _err as Error
+	}
+	equal(err!.message, 'Timeout 0ms')
+})
+test.run()

package/server/compression/index.test.ts

@@ -0,0 +1,19 @@
+import { test } from 'uvu'
+import { equal } from 'uvu/assert'
+import { compression_middleware_ } from './index.js'
+test('compression_middleware_|loads', ()=>{
+	equal(typeof compression_middleware_, 'function')
+})
+test('compression_middleware_|returns middleware', ()=>{
+	const middleware = compression_middleware_()
+	equal(typeof middleware, 'function')
+})
+test('compression_middleware_|accepts gzip type', ()=>{
+	const middleware = compression_middleware_({ type: 'gzip' })
+	equal(typeof middleware, 'function')
+})
+test('compression_middleware_|accepts deflate type', ()=>{
+	const middleware = compression_middleware_({ type: 'deflate' })
+	equal(typeof middleware, 'function')
+})
+test.run()

package/server/export/cloudflare/index.js

@@ -1,103 +1,17 @@
 /// <reference types="bun-types" />
 /// <reference types="./index.d.ts" />
-import { build } from 'esbuild'
-import { mkdir, writeFile } from 'node:fs/promises'
-import { dirname, join, resolve } from 'node:path'
-import { static_export_ } from '../index.js'
+import {
+	cloudflare_export_ as _cloudflare_export_,
+	worker_entry__generate_,
+	wrangler_toml__generate_,
+} from 'rebuildjs/server/export/cloudflare'
+import { static_export_ as _static_export_ } from 'rebuildjs/server/export'
+import { app__start } from '../../app/index.js'
+export { worker_entry__generate_, wrangler_toml__generate_ }
 /**
  * @param {cloudflare_export_config_T} config
  * @returns {Promise<cloudflare_export_result_T>}
  */
-export async function cloudflare_export_(config) {
-	const {
-		dynamic_routes = [],
-		worker_out = 'dist/worker',
-		wrangler = {},
-		...static_config
-	} = config
-	const static_result = await static_export_(static_config)
-	let worker_entry_path
-	if (dynamic_routes.length > 0) {
-		const entry_source = worker_entry__generate_(dynamic_routes)
-		const generated_path = join(worker_out, '_worker.src.js')
-		await mkdir(worker_out, { recursive: true })
-		await writeFile(generated_path, entry_source)
-		worker_entry_path = join(worker_out, '_worker.js')
-		await build({
-			entryPoints: [generated_path],
-			bundle: true,
-			format: 'esm',
-			target: 'es2022',
-			platform: 'browser',
-			outfile: worker_entry_path,
-			minify: true,
-		})
-		console.info(`[cloudflare_export] worker bundled: ${worker_entry_path}`)
-	}
-	const wrangler_config = wrangler_toml__generate_(wrangler, static_config.out_dir)
-	const wrangler_path = 'wrangler.toml'
-	await writeFile(wrangler_path, wrangler_config)
-	console.info(`[cloudflare_export] wrote ${wrangler_path}`)
-	return {
-		...static_result,
-		worker_entry_path,
-		wrangler_path,
-	}
-}
-/**
- * @param {route_handler_T[]} dynamic_routes
- * @returns {string}
- */
-export function worker_entry__generate_(dynamic_routes) {
-	const imports = []
-	const route_checks = []
-	for (let i = 0; i < dynamic_routes.length; i++) {
-		const { pattern, handler } = dynamic_routes[i]
-		const handler_name = `handler_${i}`
-		imports.push(`import ${handler_name} from '${resolve(handler)}'`)
-		if (pattern.endsWith('/*')) {
-			const prefix = pattern.slice(0, -2)
-			route_checks.push(
-				`\tif (url.pathname.startsWith('${prefix}')) return ${handler_name}(request, env, ctx)`)
-		} else {
-			route_checks.push(
-				`\tif (url.pathname === '${pattern}') return ${handler_name}(request, env, ctx)`)
-		}
-	}
-	return `${imports.join('\n')}
-
-export default {
-	async fetch(request, env, ctx) {
-		const url = new URL(request.url)
-${route_checks.join('\n')}
-		return env.ASSETS.fetch(request)
-	}
-}
-`
-}
-/**
- * @param {Partial<wrangler_config_T>} overrides
- * @param {string} [out_dir]
- * @returns {string}
- */
-export function wrangler_toml__generate_(overrides, out_dir = 'dist/browser') {
-	const name = overrides.name || 'app'
-	const compatibility_date = overrides.compatibility_date || new Date().toISOString().slice(0, 10)
-	let toml = `name = "${name}"
-compatibility_date = "${compatibility_date}"
-pages_build_output_dir = "${out_dir}"
-`
-	if (overrides.vars) {
-		toml += '\n[vars]\n'
-		for (const [key, val] of Object.entries(overrides.vars)) {
-			toml += `${key} = "${val}"\n`
-		}
-	}
-	if (overrides.routes) {
-		for (const route of overrides.routes) {
-			toml += `\n[[routes]]\npattern = "${route.pattern}"\n`
-			if (route.zone_name) toml += `zone_name = "${route.zone_name}"\n`
-		}
-	}
-	return toml
+export function cloudflare_export_(config) {
+	return _cloudflare_export_(config, _static_export_, app__start)
 }

package/server/export/cloudflare/index.test.ts

@@ -0,0 +1,55 @@
+import { test } from 'uvu'
+import { equal, ok } from 'uvu/assert'
+import { worker_entry__generate_, wrangler_toml__generate_ } from './index.js'
+test('worker_entry__generate_|single route', ()=>{
+	const source = worker_entry__generate_([
+		{ pattern: '/api/*', handler: './handlers/api.js' }
+	])
+	ok(source.includes("import handler_0 from '"))
+	ok(source.includes("url.pathname.startsWith('/api')"))
+	ok(source.includes('env.ASSETS.fetch(request)'))
+})
+test('worker_entry__generate_|exact route', ()=>{
+	const source = worker_entry__generate_([
+		{ pattern: '/health', handler: './handlers/health.js' }
+	])
+	ok(source.includes("url.pathname === '/health'"))
+})
+test('worker_entry__generate_|multiple routes', ()=>{
+	const source = worker_entry__generate_([
+		{ pattern: '/api/*', handler: './handlers/api.js' },
+		{ pattern: '/health', handler: './handlers/health.js' }
+	])
+	ok(source.includes('handler_0'))
+	ok(source.includes('handler_1'))
+})
+test('wrangler_toml__generate_|defaults', ()=>{
+	const toml = wrangler_toml__generate_({})
+	ok(toml.includes('name = "app"'))
+	ok(toml.includes('compatibility_date'))
+	ok(toml.includes('pages_build_output_dir = "dist/browser"'))
+})
+test('wrangler_toml__generate_|custom name', ()=>{
+	const toml = wrangler_toml__generate_({ name: 'my-app' })
+	ok(toml.includes('name = "my-app"'))
+})
+test('wrangler_toml__generate_|custom out_dir', ()=>{
+	const toml = wrangler_toml__generate_({}, 'build/output')
+	ok(toml.includes('pages_build_output_dir = "build/output"'))
+})
+test('wrangler_toml__generate_|vars', ()=>{
+	const toml = wrangler_toml__generate_({
+		vars: { API_KEY: 'test123' }
+	})
+	ok(toml.includes('[vars]'))
+	ok(toml.includes('API_KEY = "test123"'))
+})
+test('wrangler_toml__generate_|routes', ()=>{
+	const toml = wrangler_toml__generate_({
+		routes: [{ pattern: 'example.com/*', zone_name: 'example.com' }]
+	})
+	ok(toml.includes('[[routes]]'))
+	ok(toml.includes('pattern = "example.com/*"'))
+	ok(toml.includes('zone_name = "example.com"'))
+})
+test.run()

package/server/export/index.js

@@ -1,154 +1,15 @@
 /// <reference types="bun-types" />
 /// <reference types="./index.d.ts" />
-import { mkdir, readFile, rm, unlink, writeFile } from 'node:fs/promises'
-import { dirname, extname, join } from 'node:path'
-import { app_ctx, port_ } from 'rebuildjs/server'
+import {
+	static_export_ as _static_export_,
+	static_export__file_path_,
+} from 'rebuildjs/server/export'
 import { app__start } from '../app/index.js'
+export { static_export__file_path_ }
 /**
  * @param {static_export_config_T} config
  * @returns {Promise<static_export_result_T>}
  */
-export async function static_export_(config) {
-	const {
-		site_url,
-		out_dir = 'dist/browser',
-		server_import = './dist/server/index.js',
-		sitemap = true,
-		url_rewrite = true,
-		incremental = false,
-		manifest: use_manifest = incremental,
-		clean = false,
-		on_export,
-	} = config
-	let { routes = [], extra_routes = [] } = config
-	const site_origin = site_url.replace(/\/$/, '')
-	const exported = []
-	const errors = []
-	let app = config.app
-	let we_started = false
-	let base_url = config.base_url
-	let server
-	try {
-		if (base_url) {
-			base_url = base_url.replace(/\/$/, '')
-			console.info(`[static_export] using external server: ${base_url}`)
-		} else if (!app) {
-			const mod = await import(server_import)
-			app = typeof mod.default === 'function' ? await mod.default() : mod.default
-			await app__start(app)
-			we_started = true
-			base_url = `http://localhost:${port_(app_ctx)}`
-			console.info(`[static_export] server running on ${base_url}`)
-		} else {
-			base_url = `http://localhost:${port_(app_ctx)}`
-			console.info(`[static_export] using provided app on ${base_url}`)
-		}
-		console.info(`[static_export] site_url: ${site_origin}`)
-		if (clean) {
-			await rm(out_dir, { recursive: true, force: true })
-		}
-		if (sitemap) {
-			try {
-				const res = await fetch(`${base_url}/sitemap.xml`)
-				if (res.ok) {
-					const xml = await res.text()
-					for (const m of xml.matchAll(/<loc>https?:\/\/[^<]+<\/loc>/g)) {
-						const url = m[0].replace(/<\/?loc>/g, '')
-						const path = new URL(url).pathname
-						const route = path === '' ? '/' : path
-						if (!routes.includes(route)) {
-							routes.push(route)
-						}
-					}
-					console.info(`[static_export] discovered ${routes.length} routes from sitemap`)
-				}
-			} catch {
-				console.warn('[static_export] sitemap fetch failed, using explicit routes only')
-			}
-		}
-		const manifest_path = join(out_dir, '.export-manifest.json')
-		let prev_manifest = []
-		if (use_manifest) {
-			try {
-				prev_manifest = JSON.parse(await readFile(manifest_path, 'utf-8'))
-			} catch {
-				// No previous manifest
-			}
-		}
-		const all_routes = [...routes, ...extra_routes]
-		for (const route of all_routes) {
-			const url = base_url + route
-			try {
-				const res = await fetch(url)
-				if (!res.ok) {
-					console.error(`[static_export] ${route} -> ${res.status} ${res.statusText}`)
-					errors.push(route)
-					continue
-				}
-				const content_type = res.headers.get('content-type') ?? ''
-				let body = await res.text()
-				if (url_rewrite) {
-					body = body.replaceAll(base_url, site_origin)
-				}
-				const file_path = static_export__file_path_(route, out_dir, content_type)
-				if (incremental) {
-					try {
-						const existing = await readFile(file_path, 'utf-8')
-						if (existing === body) {
-							exported.push(file_path)
-							continue
-						}
-					} catch {
-						// File doesn't exist yet
-					}
-				}
-				await mkdir(dirname(file_path), { recursive: true })
-				await writeFile(file_path, body)
-				exported.push(file_path)
-				on_export?.(route, file_path)
-				console.info(`[static_export] ${route} -> ${file_path} (${body.length} bytes)`)
-			} catch (err) {
-				console.error(`[static_export] ${route} -> ${err.message}`)
-				errors.push(route)
-			}
-		}
-		if (use_manifest) {
-			await mkdir(dirname(manifest_path), { recursive: true })
-			await writeFile(manifest_path, JSON.stringify(exported, null, '\t'))
-			const stale = prev_manifest.filter(f=>!exported.includes(f))
-			for (const file of stale) {
-				try {
-					await unlink(file)
-					console.info(`[static_export] deleted stale: ${file}`)
-				} catch {
-					// Already gone
-				}
-			}
-		}
-		if (errors.length > 0) {
-			console.warn(`[static_export] completed with ${errors.length} error(s)`)
-		} else {
-			console.info(`[static_export] exported ${exported.length} files`)
-		}
-	} finally {
-		// Bun.serve cleanup is handled by process exit
-	}
-	return { exported, errors }
-}
-/**
- * @param {string} route
- * @param {string} out_dir
- * @param {string} [content_type]
- * @returns {string}
- */
-export function static_export__file_path_(route, out_dir, content_type) {
-	const ext = extname(route)
-	const is_html = content_type ? content_type.includes('text/html') : !ext || ext === '.html'
-	if (ext && !is_html) {
-		return join(out_dir, route)
-	}
-	if (route === '/') {
-		return join(out_dir, 'index.html')
-	}
-	return join(out_dir, route, 'index.html')
+export function static_export_(config) {
+	return _static_export_(config, app__start)
 }

package/server/export/index.test.ts

@@ -0,0 +1,41 @@
+import { test } from 'uvu'
+import { equal } from 'uvu/assert'
+import { static_export__file_path_ } from './index.js'
+test('static_export__file_path_|/ returns index.html', ()=>{
+	equal(static_export__file_path_('/', 'dist'), 'dist/index.html')
+})
+test('static_export__file_path_|/about returns about/index.html', ()=>{
+	equal(static_export__file_path_('/about', 'dist'), 'dist/about/index.html')
+})
+test('static_export__file_path_|/nested/path returns nested/path/index.html', ()=>{
+	equal(static_export__file_path_('/nested/path', 'dist'), 'dist/nested/path/index.html')
+})
+test('static_export__file_path_|/robots.txt with text/plain content-type returns bare file', ()=>{
+	equal(static_export__file_path_('/robots.txt', 'dist', 'text/plain'), 'dist/robots.txt')
+})
+test('static_export__file_path_|/sitemap.xml with application/xml content-type returns bare file', ()=>{
+	equal(static_export__file_path_('/sitemap.xml', 'dist', 'application/xml'), 'dist/sitemap.xml')
+})
+test('static_export__file_path_|/protocol.love with text/html content-type returns index.html', ()=>{
+	equal(
+		static_export__file_path_('/protocol.love', 'dist', 'text/html;charset=UTF-8'),
+		'dist/protocol.love/index.html')
+})
+test('static_export__file_path_|/protocol.love without content-type falls back to bare file', ()=>{
+	equal(static_export__file_path_('/protocol.love', 'dist'), 'dist/protocol.love')
+})
+test('static_export__file_path_|/rss.xml with application/xml returns bare file', ()=>{
+	equal(static_export__file_path_('/rss.xml', 'dist', 'application/xml'), 'dist/rss.xml')
+})
+test('static_export__file_path_|/feed.json with application/json returns bare file', ()=>{
+	equal(static_export__file_path_('/feed.json', 'dist', 'application/json'), 'dist/feed.json')
+})
+test('static_export__file_path_|/page.html with text/html returns page.html/index.html', ()=>{
+	equal(
+		static_export__file_path_('/page.html', 'dist', 'text/html'),
+		'dist/page.html/index.html')
+})
+test('static_export__file_path_|/page with no extension and no content-type returns index.html', ()=>{
+	equal(static_export__file_path_('/page', 'dist'), 'dist/page/index.html')
+})
+test.run()

package/server/hono/index.test.ts

@@ -0,0 +1,80 @@
+import { Hono } from 'hono'
+import { app_ctx, ctx_, middleware_ctx__new, request_ctx__new } from 'rebuildjs/server'
+import { test } from 'uvu'
+import { equal, throws } from 'uvu/assert'
+import {
+	hono_context$_,
+	hono_context_,
+	hono_context__set,
+	request$_,
+	request_,
+	request_url$_,
+	request_url_,
+} from './index.js'
+test.after.each(()=>{
+	app_ctx.s.app.clear()
+})
+test('hono_context', async ()=>{
+	const request_ctx = request_ctx__new(middleware_ctx__new())
+	equal(hono_context$_(request_ctx)(), undefined)
+	equal(hono_context_(request_ctx), undefined)
+	// Use a real Hono context by running through a handler
+	const app = new Hono()
+	let captured_c:any
+	app.get('/', c=>{
+		captured_c = c
+		return c.text('ok')
+	})
+	await app.request('http://localhost:3000/')
+	hono_context__set(request_ctx, captured_c)
+	equal(hono_context$_(request_ctx)(), captured_c)
+	equal(hono_context_(request_ctx), captured_c)
+	// @ts-expect-error TS2345
+	throws(()=>hono_context$_(ctx_())())
+	// @ts-expect-error TS2345
+	throws(()=>hono_context_(ctx_()))
+	// @ts-expect-error TS2345
+	throws(()=>hono_context__set(ctx_(), captured_c))
+})
+test('request', async ()=>{
+	const request_ctx = request_ctx__new(middleware_ctx__new())
+	equal(request$_(request_ctx)(), undefined)
+	equal(request_(request_ctx), undefined)
+	const app = new Hono()
+	let captured_c:any
+	app.get('/', c=>{
+		captured_c = c
+		return c.text('ok')
+	})
+	await app.request('http://localhost:3000/')
+	hono_context__set(request_ctx, captured_c)
+	const req = request_(request_ctx)
+	equal(req instanceof Request, true)
+	equal(request$_(request_ctx)(), req)
+	// @ts-expect-error TS2345
+	throws(()=>request$_(ctx_())())
+	// @ts-expect-error TS2345
+	throws(()=>request_(ctx_()))
+})
+test('request_url', async ()=>{
+	const request_ctx = request_ctx__new(middleware_ctx__new())
+	equal(request_url$_(request_ctx)(), undefined)
+	equal(request_url_(request_ctx), undefined)
+	const app = new Hono()
+	let captured_c:any
+	app.get('/foo/bar', c=>{
+		captured_c = c
+		return c.text('ok')
+	})
+	await app.request('http://localhost:3000/foo/bar')
+	hono_context__set(request_ctx, captured_c)
+	const url = request_url_(request_ctx)
+	equal(url instanceof URL, true)
+	equal(url!.pathname, '/foo/bar')
+	equal(request_url$_(request_ctx)(), url)
+	// @ts-expect-error TS2345
+	throws(()=>request_url$_(ctx_())())
+	// @ts-expect-error TS2345
+	throws(()=>request_url_(ctx_()))
+})
+test.run()

package/server/index.test.ts

@@ -0,0 +1,64 @@
+import { test } from 'uvu'
+import { equal } from 'uvu/assert'
+import * as server from './index.js'
+// Adapter interface conformance: verify rhonojs/server exports the expected API surface
+// These are the functions/signals that both adapters must provide
+const required_exports = [
+	// From rebuildjs/server (re-exported)
+	'app_ctx',
+	'middleware_ctx__new',
+	'request_ctx__new',
+	'html_response__new',
+	// html_route_ is intentionally excluded from barrel — ambiguous between rebuildjs and adapter versions.
+	// Import from 'rhonojs/server/route' or 'rebuildjs/server/route' instead.
+	'static_middleware__routes_',
+	'rebuildjs_browser__build',
+	'rebuildjs_server__build',
+	'build_id_',
+	'cwd_',
+	'port_',
+	// From rhonojs adapter modules
+	'app$_',
+	'app_',
+	'app__set',
+	'app__attach',
+	'app__start',
+	'server_entry__relative_path$_',
+	'server_entry__relative_path_',
+	'server_entry__output__relative_path$_',
+	'server_entry__output__relative_path_',
+	'server_entry__output__path$_',
+	'server_entry__output__path_',
+	'server_entry__output__link__path$_',
+	'server_entry__output__link__path_',
+	// Build
+	'rhonojs__build_id$_',
+	'rhonojs__build_id_',
+	'rhonojs__build_id__set',
+	'rhonojs__ready$_',
+	'rhonojs__ready_',
+	'rhonojs__ready__wait',
+	'rhonojs_browser__build',
+	'rhonojs_server__build',
+	'rhonojs_plugin_',
+	// Compression
+	'compression_middleware_',
+	// Hono context
+	'hono_context$_',
+	'hono_context_',
+	'hono_context__set',
+	'request$_',
+	'request_',
+	'request_url$_',
+	'request_url_',
+	// Route
+	'request_ctx__ensure',
+	// Static
+	'static_middleware_',
+]
+for (const name of required_exports) {
+	test(`exports|${name}`, ()=>{
+		equal(name in server, true, `rhonojs/server should export '${name}'`)
+	})
+}
+test.run()

package/server/route/index.js

@@ -1,6 +1,7 @@
 /// <reference types="./index.d.ts" />
-import { request_ctx__new } from 'rebuildjs/server'
+import { html_route_ as _html_route_, request_ctx__new } from 'rebuildjs/server'
 import { hono_context__set } from '../hono/index.js'
+export { html_response__new } from 'rebuildjs/server'
 /**
  * @param {middleware_ctx_T}middleware_ctx
  * @param {($p:{ ctx:request_ctx_T })=>(string|ReadableStream<string|Uint8Array>)}page_
@@ -12,38 +13,7 @@ export function html_route_(
 	page_,
 	response_init
 ) {
-	return c=>{
-		const request_ctx = request_ctx__ensure(middleware_ctx, c)
-		return html_response__new(
-			page_({ ctx: request_ctx }),
-			response_init)
-	}
-}
-/**
- * @param {string|ReadableStream}html_OR_stream
- * @param {ResponseInit}[response_init]
- * @returns {Response}
- */
-export function html_response__new(
-	html_OR_stream,
-	response_init
-) {
-	const headers = new Headers(response_init?.headers)
-	headers.set('Content-Type', 'text/html;charset=UTF-8')
-	return new Response(
-		html_OR_stream.pipeTo
-			? html_OR_stream.pipeThrough(new TextEncoderStream())
-			: new ReadableStream({
-				start(controller) {
-					controller.enqueue('' + html_OR_stream)
-					controller.close()
-				}
-			}),
-		{
-			...(response_init ?? {}),
-			headers
-		}
-	)
+	return _html_route_(middleware_ctx, page_, request_ctx__ensure, response_init)
 }
 /**
  * @param {middleware_ctx_T}middleware_ctx

package/server/route/index.test.ts

@@ -0,0 +1,98 @@
+import { Hono } from 'hono'
+import { app_ctx, middleware_ctx__new } from 'rebuildjs/server'
+import { test } from 'uvu'
+import { equal } from 'uvu/assert'
+import { hono_context_ } from '../hono/index.js'
+import { html_route_, request_ctx__ensure } from './index.js'
+test.after.each(()=>{
+	app_ctx.s.app.clear()
+})
+test('html_route_|string', async ()=>{
+	const middleware_ctx = middleware_ctx__new()
+	const html = `<!DOCTYPE html><html><head></head><body><div>Test</div></body></html>`
+	const html_route = html_route_(middleware_ctx, ()=>
+		html)
+	const app = new Hono()
+	app.get('/', html_route)
+	const response = await app.request('/')
+	equal(html, await response.text())
+})
+test('html_route_|toString', async ()=>{
+	const middleware_ctx = middleware_ctx__new()
+	const html = `<!DOCTYPE html><html><head></head><body><div>Test</div></body></html>`
+	const html_route = html_route_(middleware_ctx, ()=>(
+		{ toString: ()=>html }))
+	const app = new Hono()
+	app.get('/', html_route)
+	const response = await app.request('/')
+	equal(await response.text(), html)
+})
+test('html_route_|ReadableStream|string', async ()=>{
+	const middleware_ctx = middleware_ctx__new()
+	const html = `<!DOCTYPE html><html><head></head><body><div>Test</div></body></html>`
+	const html_route = html_route_(middleware_ctx, ()=>
+		new ReadableStream({
+			start(controller) {
+				let first = true
+				for (const chunk of html.split('>')) {
+					if (!first) controller.enqueue('>')
+					first = false
+					if (chunk != null) controller.enqueue(chunk)
+				}
+				controller.close()
+			}
+		}))
+	const app = new Hono()
+	app.get('/', html_route)
+	const response = await app.request('/')
+	equal(await response.text(), html)
+})
+test('html_route_|response_init|all', async ()=>{
+	const middleware_ctx = middleware_ctx__new()
+	const html = `<!DOCTYPE html><html><head></head><body><div>Test</div></body></html>`
+	const html_route = html_route_(middleware_ctx, ()=>html, {
+		status: 403,
+		statusText: 'Forbidden',
+		headers: {
+			'Content-Type': 'application/json',
+			'FOO': 'BAR',
+		}
+	})
+	const app = new Hono()
+	app.get('/', html_route)
+	const response = await app.request('/')
+	equal(response.status, 403)
+	equal(response.statusText, 'Forbidden')
+	equal(response.headers.get('Content-Type'), 'text/html;charset=UTF-8')
+	equal(response.headers.get('FOO'), 'BAR')
+})
+test('html_route_|response_init|additional headers', async ()=>{
+	const middleware_ctx = middleware_ctx__new()
+	const html = `<!DOCTYPE html><html><head></head><body><div>Test</div></body></html>`
+	const html_route = html_route_(middleware_ctx, ()=>html, {
+		headers: {
+			'FOO': 'BAR'
+		}
+	})
+	const app = new Hono()
+	app.get('/', html_route)
+	const response = await app.request('/')
+	equal(response.status, 200)
+	equal(response.headers.get('Content-Type'), 'text/html;charset=UTF-8')
+	equal(response.headers.get('FOO'), 'BAR')
+})
+test('request_ctx__ensure', async ()=>{
+	const middleware_ctx = middleware_ctx__new()
+	let captured_request_ctx:any
+	const app = new Hono()
+	app.get('/', c=>{
+		const request_ctx = request_ctx__ensure(middleware_ctx, c)
+		captured_request_ctx = request_ctx
+		equal(c.get('request_ctx'), request_ctx)
+		equal(hono_context_(request_ctx), c)
+		return c.text('ok')
+	})
+	await app.request('/')
+	equal(captured_request_ctx != null, true)
+})
+test.run()

package/server/static/index.js

@@ -1,34 +1,16 @@
 /// <reference types="bun-types" />
 /// <reference types="./index.d.ts" />
-import { file, Glob } from 'bun'
-import { ext_R_mime } from 'ctx-core/http'
 import { Hono } from 'hono'
-import { extname, join } from 'node:path'
-import { app_ctx, browser_path_ } from 'rebuildjs/server'
+import { static_middleware__routes_ } from 'rebuildjs/server'
 /**
  * @param {static_middleware__config_T}[config]
  * @returns {Promise<Hono>}
  */
 export async function static_middleware_(config) {
 	const app = new Hono()
-	const glob = new Glob('**')
-	for await (const relative_path of glob.scan(browser_path_(app_ctx))) {
-		const url_path = join('/', relative_path)
-		const content_type = ext_R_mime[extname(relative_path)] ?? 'text/plain'
-		const path = join(browser_path_(app_ctx), relative_path)
-		const headers = (config?.headers_ ?? (()=>({})))(
-			url_path,
-			content_type,
-			path)
-		app.get(url_path, c=>{
-			const file_ref = file(path)
-			return new Response(file_ref.size ? file_ref.stream() : '', {
-				headers: {
-					'Content-Type': content_type,
-					...headers,
-				}
-			})
-		})
+	const routes = await static_middleware__routes_(config)
+	for (const { url_path, handler } of routes) {
+		app.get(url_path, c=>handler())
 	}
 	return app
 }

package/server/static/index.test.ts

@@ -0,0 +1,11 @@
+import { app_ctx } from 'rebuildjs/server'
+import { test } from 'uvu'
+import { equal } from 'uvu/assert'
+import './index.js'
+test.after.each(()=>{
+	app_ctx.s.app.clear()
+})
+test('static_middleware_|loads', ()=>{
+	equal(1, 1)
+})
+test.run()