rhonojs 0.1.0

package/browser/index.d.ts

@@ -0,0 +1 @@
+export * from 'rebuildjs/browser'

package/browser/index.js

@@ -0,0 +1 @@
+export * from 'rebuildjs/browser'

package/index.d.ts

@@ -0,0 +1 @@
+export {}

package/index.js

@@ -0,0 +1 @@
+export {}

package/package.json

@@ -0,0 +1,66 @@
+{
+	"name": "rhonojs",
+	"version": "0.1.0",
+	"description": "Reactive Web app server focusing on MPAs with a simple server route & browser build api...uses Hono, ESBuild, rmemo, & ctx-core",
+	"keywords": [
+		"reactive",
+		"web app",
+		"web server",
+		"hono",
+		"cloudflare workers",
+		"esbuild",
+		"rmemo",
+		"ctx-core"
+	],
+	"homepage": "https://github.com/btakita/rhonojs#readme",
+	"license": "Apache-2.0",
+	"author": {
+		"name": "Brian Takita",
+		"url": "https://briantakita.me",
+		"email": "info+rhonojs@briantakita.me"
+	},
+	"type": "module",
+	"files": [
+		"*.d.ts",
+		"*.js",
+		"*.json",
+		"browser",
+		"server",
+		"types"
+	],
+	"exports": {
+		".": {
+			"types": "./index.d.ts",
+			"default": "./index.js"
+		},
+		"./browser": {
+			"types": "./browser/index.d.ts",
+			"default": "./browser/index.js"
+		},
+		"./types": {
+			"types": "./types/index.d.ts"
+		},
+		"./server": {
+			"types": "./server/index.d.ts",
+			"default": "./server/index.js"
+		},
+		"./server/export": {
+			"types": "./server/export/index.d.ts",
+			"default": "./server/export/index.js"
+		},
+		"./server/export/cloudflare": {
+			"types": "./server/export/cloudflare/index.d.ts",
+			"default": "./server/export/cloudflare/index.js"
+		},
+		"./package.json": "./package.json"
+	},
+	"dependencies": {
+		"ctx-core": "*",
+		"hono": "^4.0.0",
+		"rebuildjs": "*"
+	},
+	"peerDependencies": {
+		"esbuild": "^0.27.3"
+	},
+	"sideEffects": false
+}

package/server/app/index.d.ts

@@ -0,0 +1,15 @@
+import type { ctx__be_T, ctx__get_T, ctx__set_T, sig_T } from 'ctx-core/rmemo'
+import type { Hono } from 'hono'
+export declare const app$_:ctx__be_T<sig_T<Hono|undefined>, 'app'>
+export declare const app_:ctx__get_T<Hono|undefined, 'app'>
+export declare const app__set:ctx__set_T<Hono|undefined, 'app'>
+export declare const server_entry__relative_path$_:ctx__be_T<sig_T<string|undefined>, 'app'>
+export declare const server_entry__relative_path_:ctx__get_T<string|undefined, 'app'>
+export declare const server_entry__output__relative_path$_:ctx__be_T<sig_T<string|undefined>, 'app'>
+export declare const server_entry__output__relative_path_:ctx__get_T<string|undefined, 'app'>
+export declare const server_entry__output__path$_:ctx__be_T<sig_T<string|undefined>, 'app'>
+export declare const server_entry__output__path_:ctx__get_T<string|undefined, 'app'>
+export declare const server_entry__output__link__path$_:ctx__be_T<sig_T<string|undefined>, 'app'>
+export declare const server_entry__output__link__path_:ctx__get_T<string|undefined, 'app'>
+export declare function app__attach(app?:Hono):Promise<Hono>
+export declare function app__start(app?:Hono):Promise<Hono>

package/server/app/index.js

@@ -0,0 +1,175 @@
+import { file_exists_, file_exists__waitfor } from 'ctx-core/fs'
+import {
+	calling,
+	memo_,
+	ns_id_be_memo_pair_,
+	ns_id_be_sig_triple_,
+	nullish__none_,
+	off,
+	promise__cancel,
+	promise__cancel__throw,
+	ref__bind,
+	rmemo__wait,
+	run,
+	tup
+} from 'ctx-core/rmemo'
+import { Hono } from 'hono'
+import { dirname, join } from 'node:path'
+import {
+	app__relative_path_,
+	app_ctx,
+	browser__metafile$_,
+	build_id_,
+	cwd_,
+	metafile__wait,
+	port_,
+	server__metafile_,
+	server__output_,
+	server__output__relative_path_,
+	server__output__relative_path_M_middleware_ctx_
+} from 'rebuildjs/server'
+export const [
+	app$_,
+	app_,
+	app__set
+] = ns_id_be_sig_triple_(
+	'app',
+	'app',
+	()=>undefined)
+export const [
+	server_entry__relative_path$_,
+	server_entry__relative_path_,
+] = ns_id_be_memo_pair_(
+	'app',
+	'server_entry__relative_path',
+	ctx=>
+		join(app__relative_path_(ctx), 'index.ts'))
+export const [
+	server_entry__output__relative_path$_,
+	server_entry__output__relative_path_,
+] = ns_id_be_memo_pair_(
+	'app',
+	'server_entry__output__relative_path',
+	ctx=>
+		nullish__none_(tup(server__metafile_(ctx), server_entry__relative_path_(ctx)),
+			(server__metafile, server_entry__relative_path)=>{
+				const { outputs } = server__metafile
+				for (const output_path in outputs) {
+					const output = outputs[output_path]
+					if (output.entryPoint === server_entry__relative_path) return output_path
+				}
+			}))
+export const [
+	server_entry__output__path$_,
+	server_entry__output__path_,
+] = ns_id_be_memo_pair_(
+	'app',
+	'server_entry__output__path',
+	ctx=>
+		nullish__none_(tup(cwd_(ctx), server_entry__output__relative_path_(ctx)),
+			(cwd, server_entry__output__relative_path)=>
+				join(cwd, server_entry__output__relative_path)))
+export const [
+	server_entry__output__link__path$_,
+	server_entry__output__link__path_,
+] = ns_id_be_memo_pair_(
+	'app',
+	'server_entry__output__link__path',
+	ctx=>
+		nullish__none_([server_entry__output__path_(ctx)],
+			server_entry__output__path=>
+				join(dirname(server_entry__output__path), 'index.js')))
+/**
+ * @param {Hono}[app]
+ * @returns {Promise<Hono>}
+ */
+export async function app__attach(app) {
+	await metafile__wait(app_ctx)
+	const neq_undefined = val=>val !== undefined
+	await rmemo__wait(browser__metafile$_(app_ctx), neq_undefined)
+	const app$ = app$__new()
+	const val = await rmemo__wait(app$, app=>app, 10_000)
+	if (val instanceof Error) {
+		throw val
+	}
+	return val
+	function app$__new() {
+		return calling(memo_(app$=>{
+			app ??= new Hono()
+			app._rhonojs = 1
+			const build_id = build_id_(app_ctx)
+			const server__output__relative_path_M_middleware_ctx = server__output__relative_path_M_middleware_ctx_(app_ctx)
+			const middleware_a1 = []
+			run(async ()=>{
+				for (
+					const middleware_ctx of server__output__relative_path_M_middleware_ctx.values()
+				) {
+					const output = server__output_(middleware_ctx)
+					if (!output) {
+						return
+					}
+					if (output.entryPoint !== server_entry__relative_path_(app_ctx)) {
+						await file_exists__waitfor(async ()=>{
+							const path = join(cwd_(app_ctx), server__output__relative_path_(middleware_ctx))
+							if (!await cmd(file_exists_(path))) {
+								return false
+							}
+							const server__middleware_ =
+								await cmd(import(path).then(mod=>mod.default))
+							if (server__middleware_) {
+								middleware_a1.push(server__middleware_(middleware_ctx))
+							} else {
+								console.warn('module ' + path + ' does not export a default function')
+								return false
+							}
+							return true
+						})
+					}
+				}
+				for (const middleware of middleware_a1) {
+					app.use(middleware)
+				}
+				app$.set(app)
+			}).catch(err=>{
+				app$.set(err)
+			})
+			return app$.val
+			async function cmd(promise) {
+				if (cancel_()) promise__cancel__throw(promise)
+				if (!promise) return promise
+				ref__bind(promise, calling(memo_(rhonojs_cancel$=>{
+					if (cancel_()) {
+						promise__cancel(promise)
+						off(rhonojs_cancel$)
+					}
+				})))
+				const ret = await promise
+				if (cancel_()) promise__cancel__throw(promise)
+				return ret
+			}
+			function cancel_() {
+				return (
+					build_id_(app_ctx) !== build_id
+					|| server__output__relative_path_M_middleware_ctx_(app_ctx) !== server__output__relative_path_M_middleware_ctx
+				)
+			}
+		}))
+	}
+}
+/**
+ * @param {Hono}[app]
+ * @returns {Promise<Hono>}
+ */
+export async function app__start(app) {
+	if (!app?._rhonojs) {
+		app = await app__attach(app)
+	}
+	app__set(app_ctx, app)
+	const port = port_(app_ctx)
+	Bun.serve({
+		port,
+		fetch: app.fetch,
+	})
+	console.info(`server started on port ${port}`)
+	return app
+}

package/server/build/index.d.ts

@@ -0,0 +1,23 @@
+import type { ctx__be_T, ctx__get_T, ctx__set_T, sig_T } from 'ctx-core/rmemo'
+import type { BuildContext, Plugin } from 'esbuild'
+import type { rebuildjs_build_config_T } from 'rebuildjs/server'
+export declare const rhonojs__build_id$_:ctx__be_T<sig_T<string>, 'app'>
+export declare const rhonojs__build_id_:ctx__get_T<string, 'app'>
+export declare const rhonojs__build_id__set:ctx__set_T<string, 'app'>
+export declare const rhonojs__ready$_:ctx__be_T<sig_T<boolean>, 'app'>
+export declare const rhonojs__ready_:ctx__get_T<boolean, 'app'>
+export declare function rhonojs__ready__wait(timeout?:number):Promise<void>
+export declare function rhonojs_browser__build(
+	config?:rhonojs__build_config_T
+):Promise<BuildContext>
+export declare function rhonojs_server__build(
+	config?:rhonojs__build_config_T
+):Promise<BuildContext>
+export declare function rhonojs_plugin_(config?:rhonojs_plugin_config_T):Plugin
+export type rhonojs__build_config_T =
+	& rebuildjs_build_config_T
+	& { rhonojs?:rhonojs_plugin_config_T }
+export type rhonojs_plugin_config_T = {
+	server_entry?:string
+	app__start?:boolean
+}

package/server/build/index.js

@@ -0,0 +1,202 @@
+/// <reference types="esbuild" />
+/// <reference types="./index.d.ts" />
+import { file_exists_, file_exists__waitfor } from 'ctx-core/fs'
+import {
+	calling,
+	Cancel,
+	ns_id_be,
+	ns_id_be_memo_pair_,
+	ns_id_be_sig_triple_,
+	nullish__none_,
+	promise__cancel,
+	promise__cancel__throw,
+	ref__bind,
+	run
+} from 'ctx-core/rmemo'
+import { Hono } from 'hono'
+import { link, rm } from 'node:fs/promises'
+import { join } from 'node:path'
+import {
+	app_ctx,
+	app_path_,
+	build_id_,
+	memo_,
+	metafile__build_id_,
+	off,
+	port_,
+	rebuildjs__esbuild__done_,
+	rebuildjs__ready_,
+	rebuildjs_browser__build,
+	rebuildjs_server__build,
+	rmemo__wait
+} from 'rebuildjs/server'
+import { app_, app__start, server_entry__output__link__path_, server_entry__output__path_ } from '../app/index.js'
+export const [
+	rhonojs__build_id$_,
+	rhonojs__build_id_,
+	rhonojs__build_id__set,
+] = ns_id_be_sig_triple_(
+	'app',
+	'rhonojs_plugin__build_id',
+	()=>undefined)
+export const [
+	rhonojs__ready$_,
+	rhonojs__ready_,
+] = ns_id_be_memo_pair_(
+	'app',
+	'rhonojs__ready',
+	ctx=>
+		!!(
+			build_id_(ctx)
+			&& rebuildjs__ready_(ctx)
+			&& build_id_(ctx) === metafile__build_id_(ctx)
+			&& build_id_(ctx) === rhonojs__build_id_(ctx)))
+/**
+ * @param {number}[timeout]
+ * @returns {Promise<void>}
+ */
+export function rhonojs__ready__wait(timeout) {
+	return rmemo__wait(
+		rhonojs__ready$_(app_ctx),
+		ready=>ready,
+		timeout ?? 5000)
+}
+/**
+ * @param {rhonojs__build_config_T}[config]
+ */
+export function rhonojs_browser__build(config) {
+	const {
+		rhonojs,
+		...rebuildjs__config
+	} = config ?? {}
+	return rebuildjs_browser__build(rebuildjs__config)
+}
+/**
+ * @param {rhonojs__build_config_T}[config]
+ * @returns {Promise<void>}
+ */
+export function rhonojs_server__build(config) {
+	const {
+		rhonojs,
+		...rebuildjs__config
+	} = config ?? {}
+	const plugins = [rhonojs_plugin_(rhonojs), ...(config?.plugins ?? [])]
+	const entryPoints = config?.entryPoints ?? []
+	const server_entry = rhonojs?.server_entry ?? join(app_path_(app_ctx), 'index.ts')
+	entryPoints.push({ in: server_entry, out: 'index' })
+	return rebuildjs_server__build({
+		...rebuildjs__config,
+		entryPoints,
+		plugins,
+	})
+}
+/**
+ * @param {rhonojs_plugin_config_T}[config]
+ * @returns {Plugin}
+ */
+export function rhonojs_plugin_(config) {
+	return { name: 'rhonojs_plugin', setup: setup_() }
+	function setup_() {
+		const setup = build=>{
+			build.onEnd(async result=>{
+				if (result.errors.length) {
+					throw new Error(`Build errors: ${result.errors.length} errors`)
+				}
+			})
+		}
+		ref__bind(setup, rhonojs__link$_())
+		return setup
+		function rhonojs__link$_() {
+			return ns_id_be(
+				app_ctx,
+				'app',
+				'rhonojs__link$',
+				ctx=>
+					calling(memo_(()=>{
+						if (!rebuildjs__esbuild__done_(ctx)) return
+						nullish__none_([
+							build_id_(ctx),
+							server_entry__output__path_(ctx),
+							server_entry__output__link__path_(ctx),
+						], (
+							build_id,
+							server_entry__output__path,
+							server_entry__output__link__path,
+						)=>{
+							run(async ()=>{
+								try {
+									await Promise.all([
+										file_exists__waitfor(async ()=>{
+											await cmd(
+												rm(server_entry__output__link__path, { force: true }))
+											await cmd(
+												link(server_entry__output__path, server_entry__output__link__path))
+											return true
+										}),
+										file_exists__waitfor(async ()=>{
+											await cmd(
+												rm(
+													server_entry__output__link__path + '.map',
+													{ force: true }))
+											await cmd(
+												link(
+													server_entry__output__path + '.map',
+													server_entry__output__link__path + '.map'))
+											return true
+										})
+									])
+									rhonojs__build_id__set(ctx, build_id)
+									if (config?.app__start ?? true) {
+										const _app = app_(ctx)
+										if (_app) {
+											// Previous Bun.serve server will be replaced
+										}
+										try {
+											await cmd(rhonojs__ready__wait(30_000))
+											await cmd(file_exists__waitfor(server_entry__output__link__path))
+											await cmd(file_exists__waitfor(async ()=>{
+												if (!await file_exists_(server_entry__output__link__path)) {
+													return false
+												}
+												let app = new Hono()
+												app.route('/',
+													await cmd(import(server_entry__output__link__path))
+														.then(mod=>mod.default()))
+												await cmd(app__start(app))
+												return true
+											}))
+										} catch (err) {
+											if (err instanceof Cancel) return
+											throw err
+										}
+									}
+								} catch (err) {
+									if (err instanceof Cancel) return
+									throw err
+								}
+							})
+							async function cmd(promise) {
+								if (cancel_()) promise__cancel__throw(promise)
+								if (!promise) return promise
+								ref__bind(promise, calling(memo_(rhonojs_cancel$=>{
+									if (cancel_()) {
+										promise__cancel(promise)
+										off(rhonojs_cancel$)
+									}
+								})))
+								const ret = await promise
+								if (cancel_()) promise__cancel__throw(promise)
+								return ret
+							}
+							function cancel_() {
+								return (
+									build_id_(ctx) !== build_id
+									|| server_entry__output__path_(ctx) !== server_entry__output__path
+									|| server_entry__output__link__path_(ctx) !== server_entry__output__link__path
+								)
+							}
+						})
+					})))
+		}
+	}
+}

package/server/compression/index.d.ts

@@ -0,0 +1,5 @@
+import type { MiddlewareHandler } from 'hono'
+export type compression_middleware_config_T = {
+	type?:'gzip'|'deflate'
+}
+export declare const compression_middleware_:(config?:compression_middleware_config_T)=>MiddlewareHandler

package/server/compression/index.js

@@ -0,0 +1,11 @@
+/// <reference types="./index.d.ts" />
+import { compress } from 'hono/compress'
+/**
+ * @param {compression_middleware_config_T}[config]
+ * @returns {import('hono').MiddlewareHandler}
+ */
+export function compression_middleware_(config) {
+	return compress({
+		encoding: config?.type ?? 'gzip',
+	})
+}

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

@@ -0,0 +1,34 @@
+import type { static_export_config_T, static_export_result_T } from '../index.js'
+export declare function cloudflare_export_(
+	config:cloudflare_export_config_T
+):Promise<cloudflare_export_result_T>
+export declare function worker_entry__generate_(
+	dynamic_routes:route_handler_T[]
+):string
+export declare function wrangler_toml__generate_(
+	overrides:Partial<wrangler_config_T>,
+	out_dir?:string
+):string
+export type cloudflare_export_config_T =
+	& static_export_config_T
+	& {
+		dynamic_routes?:route_handler_T[]
+		worker_out?:string
+		wrangler?:Partial<wrangler_config_T>
+	}
+export type cloudflare_export_result_T =
+	& static_export_result_T
+	& {
+		worker_entry_path?:string
+		wrangler_path:string
+	}
+export type route_handler_T = {
+	pattern:string
+	handler:string
+}
+export type wrangler_config_T = {
+	name:string
+	compatibility_date:string
+	vars?:Record<string, string>
+	routes?:{ pattern:string, zone_name?:string }[]
+}

package/server/export/cloudflare/index.js

@@ -0,0 +1,103 @@
+/// <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'
+/**
+ * @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
+}

package/server/export/index.d.ts

@@ -0,0 +1,28 @@
+import type { Hono } from 'hono'
+export declare function static_export_(
+	config:static_export_config_T
+):Promise<static_export_result_T>
+export declare function static_export__file_path_(
+	route:string,
+	out_dir:string,
+	content_type?:string
+):string
+export type static_export_config_T = {
+	routes?:string[]
+	site_url:string
+	out_dir?:string
+	base_url?:string
+	server_import?:string
+	app?:Hono
+	sitemap?:boolean
+	extra_routes?:string[]
+	url_rewrite?:boolean
+	incremental?:boolean
+	manifest?:boolean
+	clean?:boolean
+	on_export?:(route:string, file:string)=>void
+}
+export type static_export_result_T = {
+	exported:string[]
+	errors:string[]
+}

package/server/export/index.js

@@ -0,0 +1,154 @@
+/// <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 { app__start } from '../app/index.js'
+/**
+ * @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')
+}

package/server/hono/index.d.ts

@@ -0,0 +1,9 @@
+import type { ctx__be_T, ctx__get_T, ctx__set_T, sig_T } from 'ctx-core/rmemo'
+import type { Context } from 'hono'
+export declare const hono_context$_:ctx__be_T<sig_T<Context|undefined>, 'request'>
+export declare const hono_context_:ctx__get_T<Context|undefined, 'request'>
+export declare const hono_context__set:ctx__set_T<Context|undefined, 'request'>
+export declare const request$_:ctx__be_T<sig_T<Request|undefined>, 'request'>
+export declare const request_:ctx__get_T<Request|undefined, 'request'>
+export declare const request_url$_:ctx__be_T<sig_T<URL|undefined>, 'request'>
+export declare const request_url_:ctx__get_T<URL|undefined, 'request'>

package/server/hono/index.js

@@ -0,0 +1,26 @@
+import { ns_id_be_memo_pair_, ns_id_be_sig_triple_, nullish__none_ } from 'ctx-core/rmemo'
+export const [
+	hono_context$_,
+	hono_context_,
+	hono_context__set,
+] = ns_id_be_sig_triple_(
+	'request',
+	'hono_context',
+	()=>undefined)
+export const [
+	request$_,
+	request_,
+] = ns_id_be_memo_pair_(
+	'request',
+	'request',
+	ctx=>
+		hono_context_(ctx)?.req?.raw)
+export const [
+	request_url$_,
+	request_url_,
+] = ns_id_be_memo_pair_(
+	'request',
+	'request_url',
+	ctx=>
+		nullish__none_([request_(ctx)],
+			request=>new URL(request.url)))

package/server/index.d.ts

@@ -0,0 +1,7 @@
+export * from 'rebuildjs/server'
+export * from './app/index.js'
+export * from './build/index.js'
+export * from './compression/index.js'
+export * from './hono/index.js'
+export * from './route/index.js'
+export * from './static/index.js'

package/server/index.js

@@ -0,0 +1,7 @@
+export * from 'rebuildjs/server'
+export * from './app/index.js'
+export * from './build/index.js'
+export * from './compression/index.js'
+export * from './hono/index.js'
+export * from './route/index.js'
+export * from './static/index.js'

package/server/route/index.d.ts

@@ -0,0 +1,16 @@
+/// <reference lib="dom" />
+import type { Context } from 'hono'
+import type { middleware_ctx_T, request_ctx_T } from 'rebuildjs/server'
+export declare function html_route_(
+	middleware_ctx:middleware_ctx_T,
+	page_:($p:{ ctx:request_ctx_T })=>({ toString():string }|ReadableStream<string>),
+	response_init?:ResponseInit
+):(c:Context)=>Response
+export declare function request_ctx__ensure(
+	middleware_ctx:middleware_ctx_T,
+	c:Context,
+):request_ctx_T
+export declare function html_response__new(
+	html_OR_stream:string|ReadableStream,
+	response_init?:ResponseInit
+):Response

package/server/route/index.js

@@ -0,0 +1,63 @@
+/// <reference types="./index.d.ts" />
+import { request_ctx__new } from 'rebuildjs/server'
+import { hono_context__set } from '../hono/index.js'
+/**
+ * @param {middleware_ctx_T}middleware_ctx
+ * @param {($p:{ ctx:request_ctx_T })=>(string|ReadableStream<string|Uint8Array>)}page_
+ * @param {ResponseInit}[response_init]
+ * @returns {(c:Context)=>Response}
+ */
+export function html_route_(
+	middleware_ctx,
+	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
+		}
+	)
+}
+/**
+ * @param {middleware_ctx_T}middleware_ctx
+ * @param {Context}c
+ */
+export function request_ctx__ensure(
+	middleware_ctx,
+	c,
+) {
+	let request_ctx = c.get('request_ctx')
+	if (!request_ctx) {
+		request_ctx = request_ctx__new(middleware_ctx)
+		c.set('request_ctx', request_ctx)
+	}
+	hono_context__set(request_ctx, c)
+	return request_ctx
+}

package/server/static/index.d.ts

@@ -0,0 +1,7 @@
+import type { Hono } from 'hono'
+export declare function static_middleware_(
+	config?:static_middleware__config_T
+):Promise<Hono>
+export type static_middleware__config_T = {
+	headers_?:(url_path:string, content_type:string, path:string)=>Record<string, string>
+}

package/server/static/index.js

@@ -0,0 +1,34 @@
+/// <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'
+/**
+ * @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,
+				}
+			})
+		})
+	}
+	return app
+}

package/types/index.d.ts

@@ -0,0 +1 @@
+export * from 'rebuildjs/types'