acrylblends 0.7.0 → 0.7.2

package/lib/index.js

@@ -1,28 +1,4 @@
 import { t as Context } from "./context-DDO0cfuP.js";
 import { t as Acryl } from "./app-BM0rTCp7.js";
-//#region ../../plugins/acryl-router/src/core/index.ts
-/**
-* @module
-*
-* Acryl - Web Framework built on Web Standards
-*
-* @example
-* ```ts
-* import { Acryl } from 'acrylblends'
-* const app = new Acryl()
-*
-* app.get('/', (c) => c.text('Acryl!'))
-*
-* export default app
-* ```
-*/
-//#endregion
-//#region ../../plugins/acryl-router/src/deprecated.ts
-/**
-* The 0.4 names, kept for one release so code written against them keeps working: `App` is now `Acryl` and `AppRequest` is now `AcrylRequest`,
-* the upstream names with the project renamed. Not part of the ported core; both the plugin's root and the public package's root export these.
-*/
-/** @deprecated Use `Acryl` (`new Acryl()`); `App` is the 0.4 name and goes away in the next release. */
-const App = Acryl;
-//#endregion
+import { t as App } from "./src-0hI7M7cN.js";
 export { Acryl, App, Context };

package/lib/node-server/register.js

@@ -1,6 +1,6 @@
-import { createRequire, registerHooks } from "node:module";
-import { existsSync, readFileSync } from "node:fs";
-import { dirname } from "node:path";
+import { n as compileModule } from "../transpile-CTnWof4z.js";
+import { registerHooks } from "node:module";
+import { readFileSync } from "node:fs";
 import { fileURLToPath } from "node:url";
 //#region ../../plugins/acryl-node-server/src/register.ts
 /**
@@ -14,58 +14,16 @@ import { fileURLToPath } from "node:url";
 /** The JSX runtime the docs set up; an app's tsconfig.json (or a file's own `@jsxImportSource` pragma) chooses another. */
 const DEFAULT_IMPORT_SOURCE = "acrylblends/jsx";
 const JSX_FILE = /\.[jt]sx$/u;
-const compilers = /* @__PURE__ */ new Map();
-const importSources = /* @__PURE__ */ new Map();
-/** The app's own `typescript`, resolved from the JSX file, so each app compiles with the version it pinned. */
-function compilerFor(file) {
-	let path;
-	try {
-		path = createRequire(file).resolve("typescript");
-	} catch {
-		throw new Error(`acrylblends: ${file} contains JSX, and compiling it needs the typescript package in this app: npm install --save-dev typescript`);
-	}
-	let compiler = compilers.get(path);
-	if (compiler === void 0) {
-		compiler = createRequire(path)(path);
-		compilers.set(path, compiler);
-	}
-	return compiler;
-}
-/** `jsxImportSource` of the tsconfig.json nearest to the file (following `extends`), read once per config. */
-function importSourceFor(file, ts) {
-	const config = ts.findConfigFile(dirname(file), (path) => existsSync(path));
-	if (config === void 0) return DEFAULT_IMPORT_SOURCE;
-	let source = importSources.get(config);
-	if (source === void 0) {
-		const { config: json } = ts.readConfigFile(config, (path) => ts.sys.readFile(path));
-		source = ts.parseJsonConfigFileContent(json ?? {}, ts.sys, dirname(config)).options.jsxImportSource ?? DEFAULT_IMPORT_SOURCE;
-		importSources.set(config, source);
-	}
-	return source;
-}
-/** A JSX module compiled to JavaScript, with its source map inline. */
-function compileJsx(file, text) {
-	const ts = compilerFor(file);
-	return ts.transpileModule(text, {
-		fileName: file,
-		compilerOptions: {
-			module: "esnext",
-			target: "es2022",
-			jsx: "react-jsx",
-			jsxImportSource: importSourceFor(file, ts),
-			allowImportingTsExtensions: true,
-			inlineSourceMap: true,
-			inlineSources: true
-		}
-	}).outputText;
-}
 process.setSourceMapsEnabled(true);
 registerHooks({ load(url, context, nextLoad) {
 	if (!url.startsWith("file:") || !JSX_FILE.test(new URL(url).pathname)) return nextLoad(url, context);
 	const file = fileURLToPath(url);
 	return {
 		format: "module",
-		source: compileJsx(file, readFileSync(file, "utf8")),
+		source: compileModule(file, readFileSync(file, "utf8"), {
+			defaultImportSource: DEFAULT_IMPORT_SOURCE,
+			what: "contains JSX"
+		}),
 		shortCircuit: true
 	};
 } });

package/lib/node-server.d.ts

@@ -1,3 +1,4 @@
+import { t as Acryl } from "./app-D8riatvv.js";
 import { n as UpgradeWebSocket } from "./index-BvFh1Gfx.js";
 import { ServeStaticOptions, serveStatic } from "./node-server/serve-static.js";
 import { getConnInfo } from "./node-server/conninfo.js";
@@ -5,7 +6,7 @@ import { AddressInfo } from "node:net";
 import { IncomingMessage, Server, ServerOptions, ServerResponse, createServer } from "node:http";
 import { Http2SecureServer, Http2Server, Http2ServerRequest, Http2ServerResponse, SecureServerOptions, ServerOptions as ServerOptions$1, createSecureServer, createServer as createServer$1 } from "node:http2";
 import { Duplex } from "node:stream";
-import { ServerOptions as ServerOptions$2, createServer as createServer$2 } from "node:https";
+import { Server as Server$1, ServerOptions as ServerOptions$2, createServer as createServer$2 } from "node:https";
 
 //#region ../../plugins/acryl-node-server/src/adapter/websocket-types.d.ts
 type WSReadyState = 0 | 1 | 2 | 3;
@@ -63,21 +64,47 @@ type createSecureHttp2Options = {
   createServer?: typeof createSecureServer;
 };
 type ServerOptions$3 = createHttpOptions | createHttpsOptions | createHttp2Options | createSecureHttp2Options;
-type Options = {
+type BaseOptions = {
   fetch: FetchCallback;
   overrideGlobalObjects?: boolean;
   autoCleanupIncoming?: boolean;
-  port?: number;
+  port?: number; /** The interface to listen on; `serve` uses `127.0.0.1` when it is not given. */
   hostname?: string;
   websocket?: {
     server: WebSocketServerLike;
   };
-} & ServerOptions$3;
+};
+type Options = BaseOptions & ServerOptions$3;
+/** Options for the default HTTP/1 server: `serve` and `createAdaptorServer` return an `http.Server`. */
+type HttpOptions = BaseOptions & createHttpOptions;
+/** Options naming `https.createServer`: an `https.Server`. */
+type HttpsOptions = BaseOptions & {
+  serverOptions?: ServerOptions$2;
+  createServer: typeof createServer$2;
+};
+/** Options naming `http2.createServer`: an `Http2Server`. */
+type Http2Options = BaseOptions & {
+  serverOptions?: ServerOptions$1;
+  createServer: typeof createServer$1;
+};
+/** Options naming `http2.createSecureServer`: an `Http2SecureServer`. */
+type SecureHttp2Options = BaseOptions & {
+  serverOptions?: SecureServerOptions;
+  createServer: typeof createSecureServer;
+};
 type CustomErrorHandler = (err: unknown) => void | Response | Promise<void | Response>;
 //#endregion
 //#region ../../plugins/acryl-node-server/src/adapter/server.d.ts
-declare const createAdaptorServer: (options: Options) => ServerType;
-declare const serve: (options: Options, listeningListener?: (info: AddressInfo) => void) => ServerType;
+declare function createAdaptorServer(options: SecureHttp2Options): Http2SecureServer;
+declare function createAdaptorServer(options: Http2Options): Http2Server;
+declare function createAdaptorServer(options: HttpsOptions): Server$1;
+declare function createAdaptorServer(options: HttpOptions): Server;
+declare function createAdaptorServer(options: Options): ServerType;
+declare function serve(options: SecureHttp2Options, listeningListener?: (info: AddressInfo) => void): Http2SecureServer;
+declare function serve(options: Http2Options, listeningListener?: (info: AddressInfo) => void): Http2Server;
+declare function serve(options: HttpsOptions, listeningListener?: (info: AddressInfo) => void): Server$1;
+declare function serve(options: HttpOptions, listeningListener?: (info: AddressInfo) => void): Server;
+declare function serve(options: Options, listeningListener?: (info: AddressInfo) => void): ServerType;
 //#endregion
 //#region ../../plugins/acryl-node-server/src/adapter/websocket.d.ts
 type UpgradeWebSocketOptions = {
@@ -100,4 +127,44 @@ declare class RequestError extends Error {
   });
 }
 //#endregion
-export { type Http2Bindings, type HttpBindings, RequestError, type ServeStaticOptions, type ServerType, type WebSocketData, type WebSocketLike, type WebSocketServerLike, createAdaptorServer, getConnInfo, getRequestListener, serve, serveStatic, upgradeWebSocket };
+//#region ../../plugins/acryl-node-server/src/client-modules.d.ts
+/** Options of {@link clientModules}. */
+interface ClientModulesOptions {
+  /** The folder of client modules, absolute or relative to the working directory. */
+  readonly root: string;
+  /** The folder {@link buildClientModules} wrote; with `NODE_ENV=production` it is served instead of compiling, which needs no `typescript`. */
+  readonly compiled?: string | undefined;
+  /** At most this many bytes of compiled modules are kept in memory (least recently served first out); 16 MiB when not given. */
+  readonly cacheBytes?: number | undefined;
+  /** The folder holding `jsx-dom.js` and `client.js`; the framework's own when not given. */
+  readonly runtimeDir?: string | undefined;
+}
+/** Options of {@link buildClientModules}. */
+interface BuildClientModulesOptions {
+  /** The folder of client modules, absolute or relative to the working directory. */
+  readonly root: string;
+  /** Where the compiled modules go, at the same relative paths and file names; it must not lie inside `root`. */
+  readonly outDir: string;
+  /** The folder holding `jsx-dom.js` and `client.js`; the framework's own when not given. */
+  readonly runtimeDir?: string | undefined;
+}
+/**
+ * An app serving a folder of client modules to the browser. Route it where the page's script tags point: `app.route('/client',
+ * clientModules({ root: 'src/client' }))` serves `src/client/counter.tsx` at `/client/counter.tsx`. Files are compiled on request and
+ * cached until they change (bounded by `cacheBytes`); a response carries an ETag and `Cache-Control: no-cache`, so an edit shows on the
+ * next reload. With `NODE_ENV=production` and `compiled` set, only the `compiled` folder is served and nothing is compiled.
+ * @param options - the folder, the precompiled folder, and the cache bound.
+ * @returns the app.
+ */
+declare function clientModules(options: ClientModulesOptions): Acryl;
+/**
+ * Compile a folder of client modules once, for a production that has no `typescript`: each module is written to `outDir` at the same
+ * relative path and file name (so the page's URLs stay the same), compiled exactly as {@link clientModules} compiles it, and the two
+ * browser files are copied to `outDir/@acrylblends/`. Files already in `outDir` that no source produces are left there.
+ * @param options - the source folder and the output folder.
+ * @returns the paths written, relative to `outDir`.
+ * @throws MissingTypeScriptError when the app has no `typescript`; an error when `outDir` lies inside `root`.
+ */
+declare function buildClientModules(options: BuildClientModulesOptions): string[];
+//#endregion
+export { type BuildClientModulesOptions, type ClientModulesOptions, type Http2Bindings, type HttpBindings, RequestError, type ServeStaticOptions, type ServerType, type WebSocketData, type WebSocketLike, type WebSocketServerLike, buildClientModules, clientModules, createAdaptorServer, getConnInfo, getRequestListener, serve, serveStatic, upgradeWebSocket };

package/lib/node-server.js

@@ -1,9 +1,15 @@
+import { t as Acryl } from "./app-BM0rTCp7.js";
+import { basePath } from "./route.js";
 import { defineWebSocketHelper } from "./ws.js";
 import { t as serveStatic } from "./serve-static-B14MF1Va.js";
 import { getConnInfo } from "./node-server/conninfo.js";
+import { n as compileModule, t as MissingTypeScriptError } from "./transpile-CTnWof4z.js";
 import { STATUS_CODES, ServerResponse, createServer } from "node:http";
 import { Http2ServerRequest, constants } from "node:http2";
 import { Readable } from "node:stream";
+import { copyFileSync, mkdirSync, readFileSync, readdirSync, realpathSync, statSync, writeFileSync } from "node:fs";
+import { dirname, extname, isAbsolute, join, relative, resolve, sep } from "node:path";
+import { fileURLToPath } from "node:url";
 //#region ../../plugins/acryl-node-server/src/adapter/error.ts
 var RequestError = class extends Error {
 	constructor(message, options) {
@@ -1293,9 +1299,7 @@ const upgradeWebSocket = defineWebSocketHelper(async (c, events, options) => {
 	})();
 	return new Response();
 });
-//#endregion
-//#region ../../plugins/acryl-node-server/src/adapter/server.ts
-const createAdaptorServer = (options) => {
+function createAdaptorServer(options) {
 	const fetchCallback = options.fetch;
 	const requestListener = getRequestListener(fetchCallback, {
 		hostname: options.hostname,
@@ -1312,14 +1316,267 @@ const createAdaptorServer = (options) => {
 		});
 	}
 	return server;
-};
-const serve = (options, listeningListener) => {
+}
+function serve(options, listeningListener) {
 	const server = createAdaptorServer(options);
-	server.listen(options?.port ?? 3e3, options.hostname, () => {
+	server.listen(options?.port ?? 3e3, options.hostname ?? "127.0.0.1", () => {
 		const serverInfo = server.address();
 		listeningListener && listeningListener(serverInfo);
 	});
 	return server;
+}
+//#endregion
+//#region ../../plugins/acryl-node-server/src/client-modules.ts
+/**
+* Client components without a bundler. `clientModules({ root: 'src/client' })` is an app that serves the TypeScript and JSX modules of a
+* folder to the browser as ES modules: a `.tsx`/`.ts`/`.jsx` file compiled with the app's own `typescript` (JSX for `acrylblends/jsx/dom`),
+* a `.js`/`.mjs` file as it is. The framework's own browser imports (`acrylblends/jsx/dom` with its runtimes and `client`, and
+* `acrylblends/client`) are rewritten to two self-contained files the same app serves, at a URL relative to each module, so a page needs
+* one `<script type="module" src="/client/counter.tsx">` and no import map, under whatever path the app is routed at.
+*
+* Production runs without `typescript` (a deploy that leaves out devDependencies): `buildClientModules` writes the same compiled modules
+* and the two browser files into a folder, and with `NODE_ENV=production` and `compiled` set, only that folder is served.
+*/
+/** The folder the two browser files are served from, below the app's mount. A source folder of this name is not served. */
+const RUNTIME_DIR = "@acrylblends";
+/** The framework's browser imports and the browser file that provides each. */
+const BROWSER_IMPORTS = {
+	"acrylblends/jsx/dom": "jsx-dom.js",
+	"acrylblends/jsx/dom/jsx-runtime": "jsx-dom.js",
+	"acrylblends/jsx/dom/jsx-dev-runtime": "jsx-dom.js",
+	"acrylblends/jsx/dom/client": "jsx-dom.js",
+	"acrylblends/client": "client.js"
 };
+const RUNTIME_FILES = ["jsx-dom.js", "client.js"];
+const COMPILED = /* @__PURE__ */ new Set([
+	".ts",
+	".tsx",
+	".jsx",
+	".mts"
+]);
+const SERVED = /* @__PURE__ */ new Set([
+	...COMPILED,
+	".js",
+	".mjs"
+]);
+const JS_TYPE = "text/javascript; charset=utf-8";
+/** The cache bound when `cacheBytes` is not given. */
+const DEFAULT_CACHE_BYTES = 16 * 1024 * 1024;
+/** The framework's two browser files, next to the built module that contains this code. */
+const defaultRuntimeDir = () => fileURLToPath(new URL("./browser/", import.meta.url));
+/** A module path below the root (`widgets/counter.tsx`) with the URL prefix that reaches the browser files from it. */
+const runtimePrefix = (relativePath) => {
+	const depth = relativePath.split("/").length - 1;
+	return depth === 0 ? "./" : "../".repeat(depth);
+};
+/** One client module compiled for the browser: TypeScript and JSX compiled, the framework's imports pointed at its browser files. */
+function compileForBrowser(file, relativePath) {
+	const prefix = runtimePrefix(relativePath);
+	return compileModule(file, readFileSync(file, "utf8"), {
+		importSource: "acrylblends/jsx/dom",
+		defaultImportSource: "acrylblends/jsx/dom",
+		what: "is a client module",
+		rewrite: (specifier) => {
+			const target = BROWSER_IMPORTS[specifier];
+			return target === void 0 ? void 0 : `${prefix}${RUNTIME_DIR}/${target}`;
+		}
+	});
+}
+/**
+* The path below the root a request names, or `undefined` when it must not be served: a `..` or dot segment, a backslash or NUL, an
+* extension outside the served set, or a `.d.ts` file.
+*/
+function servedPath(requestPath) {
+	let decoded;
+	try {
+		decoded = decodeURIComponent(requestPath);
+	} catch {
+		return;
+	}
+	const parts = decoded.split("/").filter((part) => part !== "");
+	if (parts.length === 0 || parts.some((part) => part.startsWith(".") || part.includes("\\") || part.includes("\0"))) return void 0;
+	const path = parts.join("/");
+	if (!SERVED.has(extname(path)) || path.endsWith(".d.ts")) return void 0;
+	return path;
+}
+/** A real file inside `root` (symbolic links followed), or `undefined`. */
+function fileInside(root, path) {
+	try {
+		const file = realpathSync(join(root, ...path.split("/")));
+		return file.startsWith(root + sep) && statSync(file).isFile() ? file : void 0;
+	} catch {
+		return;
+	}
+}
+/** A file's validator: its size and modification time. */
+const etagOf = (stat) => `"${stat.size.toString(36)}-${Math.trunc(stat.mtimeMs).toString(36)}"`;
+/** Compiled modules, least recently served first, bounded by the UTF-8 bytes of their code. Exported for its tests. */
+var CompileCache = class {
+	entries = /* @__PURE__ */ new Map();
+	bytes = 0;
+	limit;
+	constructor(limit) {
+		this.limit = limit;
+	}
+	get(file, mtimeMs, size) {
+		const entry = this.entries.get(file);
+		if (entry === void 0) return void 0;
+		this.entries.delete(file);
+		if (entry.mtimeMs !== mtimeMs || entry.size !== size) {
+			this.bytes -= entry.bytes;
+			return;
+		}
+		this.entries.set(file, entry);
+		return entry;
+	}
+	set(file, stat, code) {
+		const entry = {
+			mtimeMs: stat.mtimeMs,
+			size: stat.size,
+			etag: etagOf(stat),
+			code,
+			bytes: Buffer.byteLength(code)
+		};
+		const previous = this.entries.get(file);
+		if (previous !== void 0) {
+			this.entries.delete(file);
+			this.bytes -= previous.bytes;
+		}
+		if (entry.bytes > this.limit) return entry;
+		this.entries.set(file, entry);
+		this.bytes += entry.bytes;
+		for (const [key, old] of this.entries) {
+			if (this.bytes <= this.limit) break;
+			this.entries.delete(key);
+			this.bytes -= old.bytes;
+		}
+		return entry;
+	}
+	/** The UTF-8 bytes of code held now. */
+	get heldBytes() {
+		return this.bytes;
+	}
+	/** The files held now, least recently served first. */
+	get files() {
+		return [...this.entries.keys()];
+	}
+};
+const absolute = (path) => isAbsolute(path) ? path : resolve(path);
+/** A folder's real path; one that does not exist (a production image that ships only the compiled folder) keeps its absolute path. */
+const realFolder = (path) => {
+	try {
+		return realpathSync(absolute(path));
+	} catch {
+		return absolute(path);
+	}
+};
+/**
+* An app serving a folder of client modules to the browser. Route it where the page's script tags point: `app.route('/client',
+* clientModules({ root: 'src/client' }))` serves `src/client/counter.tsx` at `/client/counter.tsx`. Files are compiled on request and
+* cached until they change (bounded by `cacheBytes`); a response carries an ETag and `Cache-Control: no-cache`, so an edit shows on the
+* next reload. With `NODE_ENV=production` and `compiled` set, only the `compiled` folder is served and nothing is compiled.
+* @param options - the folder, the precompiled folder, and the cache bound.
+* @returns the app.
+*/
+function clientModules(options) {
+	const root = realFolder(options.root);
+	const runtimeDir = absolute(options.runtimeDir ?? defaultRuntimeDir());
+	let compiled;
+	if (process.env.NODE_ENV === "production" && options.compiled !== void 0) try {
+		compiled = realpathSync(absolute(options.compiled));
+	} catch {
+		throw new Error(`acrylblends: the compiled client folder ${absolute(options.compiled)} does not exist; build it with buildClientModules before starting in production`);
+	}
+	const cache = new CompileCache(options.cacheBytes ?? DEFAULT_CACHE_BYTES);
+	const app = new Acryl();
+	app.get("/*", (c) => {
+		const requestPath = c.req.path.slice(basePath(c).length);
+		const runtime = /^\/@acrylblends\/([a-z-]+\.js)$/u.exec(requestPath)?.[1];
+		const send = (code, etag) => {
+			if (c.req.header("if-none-match") === etag) return c.body(null, 304, {
+				etag,
+				"cache-control": "no-cache"
+			});
+			return c.body(code, 200, {
+				"content-type": JS_TYPE,
+				etag,
+				"cache-control": "no-cache"
+			});
+		};
+		const serveFile = (file) => {
+			const stat = statSync(file);
+			return send(readFileSync(file, "utf8"), etagOf(stat));
+		};
+		if (runtime !== void 0) {
+			if (!RUNTIME_FILES.includes(runtime)) return c.notFound();
+			return serveFile(compiled === void 0 ? join(runtimeDir, runtime) : join(compiled, RUNTIME_DIR, runtime));
+		}
+		const path = servedPath(requestPath);
+		if (path === void 0 || path.split("/")[0] === RUNTIME_DIR) return c.notFound();
+		if (compiled !== void 0) {
+			const file = fileInside(compiled, path);
+			if (file !== void 0) return serveFile(file);
+			if (fileInside(root, path) !== void 0) return c.text(`acrylblends: ${path} is not in ${relative(process.cwd(), compiled) || compiled}; build the client modules again (buildClientModules)`, 500);
+			return c.notFound();
+		}
+		const file = fileInside(root, path);
+		if (file === void 0) return c.notFound();
+		if (!COMPILED.has(extname(file))) return serveFile(file);
+		const stat = statSync(file);
+		let entry = cache.get(file, stat.mtimeMs, stat.size);
+		if (entry === void 0) {
+			let code;
+			try {
+				code = compileForBrowser(file, path);
+			} catch (error) {
+				if (error instanceof MissingTypeScriptError) return c.text(error.message, 500);
+				throw error;
+			}
+			entry = cache.set(file, stat, code);
+		}
+		return send(entry.code, entry.etag);
+	});
+	return app;
+}
+/** Every served file below `dir`, as paths below `root` with `/` separators; dot entries, `node_modules` and the runtime folder skipped. */
+function sourceFiles(root, dir = root) {
+	const files = [];
+	for (const entry of readdirSync(dir, { withFileTypes: true })) {
+		if (entry.name.startsWith(".") || entry.name === "node_modules" || dir === root && entry.name === RUNTIME_DIR) continue;
+		const full = join(dir, entry.name);
+		if (entry.isDirectory()) files.push(...sourceFiles(root, full));
+		else if (entry.isFile() && SERVED.has(extname(entry.name)) && !entry.name.endsWith(".d.ts")) files.push(relative(root, full).split(sep).join("/"));
+	}
+	return files.sort();
+}
+/**
+* Compile a folder of client modules once, for a production that has no `typescript`: each module is written to `outDir` at the same
+* relative path and file name (so the page's URLs stay the same), compiled exactly as {@link clientModules} compiles it, and the two
+* browser files are copied to `outDir/@acrylblends/`. Files already in `outDir` that no source produces are left there.
+* @param options - the source folder and the output folder.
+* @returns the paths written, relative to `outDir`.
+* @throws MissingTypeScriptError when the app has no `typescript`; an error when `outDir` lies inside `root`.
+*/
+function buildClientModules(options) {
+	const root = realpathSync(absolute(options.root));
+	const outDir = absolute(options.outDir);
+	const runtimeDir = absolute(options.runtimeDir ?? defaultRuntimeDir());
+	if (outDir === root || outDir.startsWith(root + sep)) throw new Error(`acrylblends: the output folder ${outDir} lies inside the client folder ${root}`);
+	const written = [];
+	for (const path of sourceFiles(root)) {
+		const source = join(root, ...path.split("/"));
+		const target = join(outDir, ...path.split("/"));
+		mkdirSync(dirname(target), { recursive: true });
+		if (COMPILED.has(extname(path))) writeFileSync(target, compileForBrowser(source, path));
+		else copyFileSync(source, target);
+		written.push(path);
+	}
+	mkdirSync(join(outDir, RUNTIME_DIR), { recursive: true });
+	for (const name of RUNTIME_FILES) {
+		copyFileSync(join(runtimeDir, name), join(outDir, RUNTIME_DIR, name));
+		written.push(`${RUNTIME_DIR}/${name}`);
+	}
+	return written;
+}
 //#endregion
-export { RequestError, createAdaptorServer, getConnInfo, getRequestListener, serve, serveStatic, upgradeWebSocket };
+export { RequestError, buildClientModules, clientModules, createAdaptorServer, getConnInfo, getRequestListener, serve, serveStatic, upgradeWebSocket };

package/lib/schema-validator.d.ts

@@ -1,28 +1,54 @@
 import { L as MiddlewareHandler, Q as ValidationTargets, v as Env } from "./context-DS3fYyG-.js";
 
 //#region ../../plugins/acryl-router/src/helpers/schema-validator.d.ts
-/** The slice of the Standard Schema interface this needs; Schemastery (what Cordis uses), Zod and Valibot all implement it. */
-interface StandardSchema<T = unknown> {
-  readonly '~standard': {
-    validate(value: unknown): StandardResult<T> | Promise<StandardResult<T>>;
-  };
+/**
+ * The Standard Schema v1 interface (https://standardschema.dev), declared here so the framework needs no dependency for it. Schemastery
+ * (what Cordis uses), Zod and Valibot implement it, and a hand-written schema object of the same shape is accepted as well. Only
+ * `validate` is called, so `version` and `vendor` may be left out of a hand-written schema.
+ */
+interface StandardSchema<Input = unknown, Output = Input> {
+  readonly '~standard': StandardSchemaProps<Input, Output>;
+}
+/** The `~standard` properties of a {@link StandardSchema}. */
+interface StandardSchemaProps<Input = unknown, Output = Input> {
+  /** The version of the standard; every library sets it. */
+  readonly version?: 1 | undefined;
+  /** The name of the schema library; every library sets it. */
+  readonly vendor?: string | undefined;
+  /** Validates an unknown value. */
+  readonly validate: (value: unknown, options?: StandardSchemaOptions | undefined) => StandardResult<Output> | Promise<StandardResult<Output>>;
+  /** The input and output types, for inference only. */
+  readonly types?: {
+    readonly input: Input;
+    readonly output: Output;
+  } | undefined;
+}
+/** Options a caller may pass to `validate`. */
+interface StandardSchemaOptions {
+  /** Library-specific parameters. */
+  readonly libraryOptions?: Record<string, unknown> | undefined;
+}
+/** One validation issue: a message and where in the value it applies. */
+interface StandardIssue {
+  readonly message: string;
+  readonly path?: readonly (PropertyKey | {
+    readonly key: PropertyKey;
+  })[] | undefined;
 }
-type StandardResult<T> = {
-  readonly value: T;
+/** What `validate` answers: the parsed value, or the issues. */
+type StandardResult<Output> = {
+  readonly value: Output;
   readonly issues?: undefined;
 } | {
-  readonly issues: readonly {
-    readonly message: string;
-    readonly path?: readonly unknown[] | undefined;
-  }[];
+  readonly issues: readonly StandardIssue[];
 };
 /**
  * The core `validator` driven by a Standard Schema. A failure answers 400 with `{ error, issues }`; success makes the parsed value the
- * handler's `c.req.valid(target)`, typed by the schema.
+ * handler's `c.req.valid(target)`, typed by the schema's output.
  */
-declare function schemaValidator<Target extends keyof ValidationTargets, Out, E extends Env = Env, P extends string = string>(target: Target, schema: StandardSchema<Out>): MiddlewareHandler<E, P, {
+declare function schemaValidator<Target extends keyof ValidationTargets, Out, E extends Env = Env, P extends string = string>(target: Target, schema: StandardSchema<unknown, Out>): MiddlewareHandler<E, P, {
   in: { [K in Target]: Out };
   out: { [K in Target]: Out };
 }>;
 //#endregion
-export { StandardSchema, schemaValidator };
+export { StandardIssue, StandardResult, StandardSchema, StandardSchemaOptions, StandardSchemaProps, schemaValidator };

package/lib/schema-validator.js

@@ -1,9 +1,9 @@
 import { t as validator } from "./validator-D84mq-dO.js";
 //#region ../../plugins/acryl-router/src/helpers/schema-validator.ts
-const pathOf = (path) => (path ?? []).map((part) => String(typeof part === "object" && part !== null && "key" in part ? part.key : part)).join(".");
+const pathOf = (path) => (path ?? []).map((part) => String(typeof part === "object" ? part.key : part)).join(".");
 /**
 * The core `validator` driven by a Standard Schema. A failure answers 400 with `{ error, issues }`; success makes the parsed value the
-* handler's `c.req.valid(target)`, typed by the schema.
+* handler's `c.req.valid(target)`, typed by the schema's output.
 */
 function schemaValidator(target, schema) {
 	return validator(target, async (value, c) => {

package/lib/src-0hI7M7cN.js

@@ -0,0 +1,27 @@
+import { t as Acryl } from "./app-BM0rTCp7.js";
+//#region ../../plugins/acryl-router/src/core/index.ts
+/**
+* @module
+*
+* Acryl - Web Framework built on Web Standards
+*
+* @example
+* ```ts
+* import { Acryl } from 'acrylblends'
+* const app = new Acryl()
+*
+* app.get('/', (c) => c.text('Acryl!'))
+*
+* export default app
+* ```
+*/
+//#endregion
+//#region ../../plugins/acryl-router/src/deprecated.ts
+/**
+* The 0.4 names, kept for one release so code written against them keeps working: `App` is now `Acryl` and `AppRequest` is now `AcrylRequest`,
+* the upstream names with the project renamed. Not part of the ported core; both the plugin's root and the public package's root export these.
+*/
+/** @deprecated Use `Acryl` (`new Acryl()`); `App` is the 0.4 name and goes away in the next release. */
+const App = Acryl;
+//#endregion
+export { App as t };