@orochibraru/svelte-smol 1.3.0

package/README.md

@@ -0,0 +1,100 @@
+# Svelte Smol Adapter
+
+A [SvelteKit](https://svelte.dev/docs/kit) adapter that compiles your app into a
+**single standalone executable** with `bun build --compile`. No `node_modules`,
+no JS files to ship — just one binary plus its static assets.
+
+## Install
+
+```bash
+bun add -d @orochibraru/svelte-adapter-bun
+```
+
+## Usage
+
+```js
+// svelte.config.js
+import adapter from "@orochibraru/svelte-adapter-bun";
+
+export default {
+  kit: {
+    adapter: adapter(),
+  },
+};
+```
+
+Because the adapter touches `Bun.*` at config-load time, run the build with the
+Bun runtime:
+
+```bash
+bun --bun vite build
+```
+
+## Output
+
+```text
+build/
+├── server        # the compiled executable
+├── client/       # static assets, served by the executable
+└── prerendered/  # prerendered pages, served by the executable
+```
+
+Deploy the whole `build/` directory (or just `server` if a proxy/CDN serves the
+assets — see `serveAssets`). The executable locates `client/` and `prerendered/`
+relative to its own path, so it can be run from any working directory:
+
+```bash
+./build/server
+```
+
+## Options
+
+```js
+adapter({
+  out: "build", // output directory
+  name: "server", // executable filename within `out`
+  target: undefined, // cross-compile target, e.g. "bun-linux-x64"
+  bytecode: false, // embed a V8 bytecode cache (faster cold start, bigger binary)
+  minify: false, // minify the bundled server code
+  sourcemap: false, // embed a source map for server stack traces
+  precompress: false, // emit + serve .gz / .br sibling files
+  envPrefix: "", // prefix for the runtime env vars below
+  serveAssets: true, // serve client/ and prerendered/ from the binary
+  serveOptions: {}, // extra Bun.serve() options (tls, reusePort, …)
+});
+```
+
+### Cross-compilation
+
+`target` accepts any Bun compile target, e.g. `"bun-linux-x64"`,
+`"bun-linux-arm64-musl"` (Alpine), `"bun-darwin-arm64"`, `"bun-windows-x64"`,
+with optional `-modern` / `-baseline` SIMD suffixes. Bun downloads the matching
+runtime the first time you use a target.
+
+## Runtime environment variables
+
+| Variable           | Default   | Purpose                                                                                         |
+| ------------------ | --------- | ----------------------------------------------------------------------------------------------- |
+| `HOST`             | `0.0.0.0` | Listen address                                                                                  |
+| `PORT`             | `3000`    | Listen port                                                                                     |
+| `SOCKET_PATH`      | —         | Listen on a Unix socket instead of `HOST`/`PORT`                                                |
+| `ASSETS_DIR`       | —         | Override where `client/` and `prerendered/` are looked up (absolute, or relative to the binary) |
+| `ORIGIN`           | —         | Absolute origin used for request URL resolution                                                 |
+| `PROTOCOL_HEADER`  | —         | Header carrying the forwarded protocol (e.g. `x-forwarded-proto`)                               |
+| `HOST_HEADER`      | —         | Header carrying the forwarded host                                                              |
+| `PORT_HEADER`      | —         | Header carrying the forwarded port                                                              |
+| `ADDRESS_HEADER`   | —         | Header carrying the client address (e.g. `x-forwarded-for`)                                     |
+| `XFF_DEPTH`        | `1`       | Trusted-proxy depth when `ADDRESS_HEADER=x-forwarded-for`                                       |
+| `BODY_SIZE_LIMIT`  | `512K`    | Max request body size (`K`/`M`/`G` suffixes allowed)                                            |
+| `IDLE_TIMEOUT`     | `10`      | Bun socket idle timeout in seconds (SSE responses opt out)                                      |
+| `SHUTDOWN_TIMEOUT` | `30`      | Seconds to wait for in-flight requests on `SIGINT`/`SIGTERM`                                    |
+
+Set `envPrefix` to namespace these (`envPrefix: "MY_APP_"` → `MY_APP_PORT`).
+
+## Notes
+
+- The SvelteKit server code is JavaScript emitted by Vite; `--compile` embeds it
+  in the binary, so nothing but the executable ships. Native (`.node`) modules in
+  your dependencies are the one thing that can't be bundled this way.
+- WebSockets, `read()` from `$app/server`, prerendering, and server
+  instrumentation are all supported.

package/index.ts

@@ -0,0 +1,238 @@
+import { fileURLToPath } from "node:url";
+import type { Adapter, Builder } from "@sveltejs/kit";
+
+export interface AdapterOptions {
+	/**
+	 * Output directory. Holds the compiled executable plus the `client/` and
+	 * `prerendered/` folders it serves.
+	 * @default "build"
+	 */
+	out?: string;
+	/**
+	 * Filename of the compiled executable, written into `out`.
+	 * @default "server"
+	 */
+	name?: string;
+	/**
+	 * Cross-compilation target for `bun build --compile`, e.g.
+	 * `"bun-linux-x64"`, `"bun-linux-arm64-musl"`, `"bun-darwin-arm64"`,
+	 * `"bun-windows-x64"` (optional `-modern` / `-baseline` SIMD suffix, and
+	 * `-musl` for Alpine). Bun downloads the matching runtime on first use.
+	 * @default the host platform
+	 */
+	target?: Bun.Build.CompileTarget;
+	/**
+	 * Emit a V8 bytecode cache into the executable for faster cold starts, at
+	 * the cost of a larger binary.
+	 * @default false
+	 */
+	bytecode?: boolean;
+	/**
+	 * Minify the bundled server code before embedding it.
+	 * @default false
+	 */
+	minify?: boolean;
+	/**
+	 * Embed a source map so server stack traces point at original code.
+	 * @default false
+	 */
+	sourcemap?: boolean;
+	/**
+	 * Pre-compress client assets and prerendered pages to `.gz` / `.br`
+	 * siblings. The handler serves them with the matching `Content-Encoding`
+	 * when the request's `Accept-Encoding` allows.
+	 * @default false
+	 */
+	precompress?: boolean;
+	/**
+	 * Prefix for this adapter's own runtime env vars (`PORT`, `HOST`,
+	 * `ORIGIN`, ...).
+	 * @default ""
+	 */
+	envPrefix?: string;
+	/**
+	 * Serve the app's static assets and prerendered pages from the
+	 * executable. The `client/` and `prerendered/` folders must sit next to
+	 * the binary (or point `ASSETS_DIR` at their parent). Turn off when a
+	 * reverse proxy or CDN serves them instead.
+	 * @default true
+	 */
+	serveAssets?: boolean;
+	/**
+	 * Extra options merged into the `Bun.serve()` call (`tls`, `reusePort`,
+	 * `maxConnections`, a custom `error` handler, ...). Applied *before* this
+	 * adapter's own required fields (`idleTimeout`, `maxRequestBodySize`,
+	 * `fetch`, `hostname`/`port`/`unix`, `websocket`), so it can't be used to
+	 * override request handling, only to add to it. Use the existing env vars
+	 * (`IDLE_TIMEOUT`, `BODY_SIZE_LIMIT`, `HOST`/`PORT`, `SOCKET_PATH`,
+	 * `SHUTDOWN_TIMEOUT`) to change those instead.
+	 * @default {}
+	 */
+	serveOptions?: Record<string, unknown>;
+}
+
+// `node:url`, not `Bun.fileURLToPath`: this module is loaded at config-parse
+// time by Node-based tooling too (svelte-check, the Svelte language server,
+// `svelte-kit sync`), where `Bun` is undefined. Everything that actually needs
+// the Bun runtime lives inside `adapt()`.
+const templates = fileURLToPath(new URL("./templates", import.meta.url));
+
+/**
+ * SvelteKit adapter that compiles the app into a single standalone executable
+ * with `bun build --compile`.
+ *
+ * `adapt()` writes the SvelteKit server and this package's entrypoint templates
+ * into a temp directory, then compiles them — `@sveltejs/kit` and every other
+ * pure-JS dependency bundled in — into one binary. The build must run under the
+ * Bun runtime (`bun --bun vite build`, or a `bunfig.toml` with `[run] bun =
+ * true`); loading the config alone works under Node too.
+ *
+ * Output, all written to {@link AdapterOptions.out | `out`}:
+ *
+ * ```text
+ * build/
+ * ├── server        the executable (rename with `name`)
+ * ├── client/       static assets, served by the executable
+ * └── prerendered/  prerendered pages, served by the executable
+ * ```
+ *
+ * The executable resolves `client/` and `prerendered/` from its own location
+ * (`dirname(process.execPath)`, overridable with the `ASSETS_DIR` env var), so
+ * it can run from any working directory. Deploy the whole `out` directory, or
+ * just the binary when {@link AdapterOptions.serveAssets | `serveAssets`} is
+ * off and a proxy/CDN serves the assets.
+ *
+ * Runtime configuration (`HOST`, `PORT`, `ORIGIN`, `BODY_SIZE_LIMIT`, …) is
+ * read from environment variables, optionally namespaced by
+ * {@link AdapterOptions.envPrefix | `envPrefix`}.
+ *
+ * @param options - see {@link AdapterOptions}
+ * @returns the configured SvelteKit {@link Adapter}
+ *
+ * @example
+ * ```js
+ * // svelte.config.js
+ * import adapter from "@orochibraru/svelte-adapter-bun";
+ *
+ * export default {
+ *   kit: {
+ *     adapter: adapter({
+ *       // cross-compile for an Alpine container from any host
+ *       target: "bun-linux-x64-musl",
+ *       bytecode: true,
+ *     }),
+ *   },
+ * };
+ * ```
+ *
+ * @see {@link https://bun.com/docs/bundler/executables | Bun — Single-file executables}
+ */
+export default function adapter(options: AdapterOptions = {}): Adapter {
+	const {
+		out = "build",
+		name = "server",
+		target,
+		bytecode = false,
+		minify = false,
+		sourcemap = false,
+		precompress = false,
+		envPrefix = "",
+		serveAssets = true,
+		serveOptions = {},
+	} = options;
+
+	return {
+		name: "homerun-svelte-adapter-bun",
+		supports: {
+			instrumentation: () => true,
+			read: () => true,
+		},
+		async adapt(builder: Builder) {
+			const { base } = builder.config.kit.paths;
+			const tmp = builder.getBuildDirectory("adapter-bun");
+
+			builder.rimraf(out);
+			builder.rimraf(tmp);
+			builder.mkdirp(`${out}/`);
+			builder.mkdirp(tmp);
+
+			builder.log.minor("Copying assets");
+			builder.writeClient(`${out}/client${base}`);
+			builder.writePrerendered(`${out}/prerendered${base}`);
+
+			if (precompress) {
+				builder.log.minor("Compressing assets");
+				await Promise.all([
+					builder.compress(`${out}/client`),
+					builder.compress(`${out}/prerendered`),
+				]);
+			}
+
+			builder.log.minor("Building server");
+			builder.writeServer(`${tmp}/server`);
+			await Bun.write(
+				`${tmp}/server/manifest.js`,
+				[
+					`export const manifest = ${builder.generateManifest({ relativePath: "./" })};`,
+					`export const prerendered = new Set(${JSON.stringify(builder.prerendered.paths)});`,
+					`export const base = ${JSON.stringify(base)};`,
+				].join("\n\n"),
+			);
+
+			// Entry templates ship as raw `.ts` — `bun build --compile` runs them
+			// straight through. The virtual specifiers (`ENV`, `MANIFEST`,
+			// `SERVER`, `HANDLER`) and the `ENV_PREFIX` / `BUILD_OPTIONS` /
+			// `SERVE_OPTIONS` tokens are resolved by this raw word-boundary token
+			// swap over the copied source.
+			builder.log.minor("Copying entrypoint");
+			builder.copy(templates, tmp, {
+				replace: {
+					BUILD_OPTIONS: JSON.stringify({ serveAssets, precompress }),
+					ENV: "./env.ts",
+					ENV_PREFIX: JSON.stringify(envPrefix),
+					HANDLER: "./handler.ts",
+					MANIFEST: "./server/manifest.js",
+					SERVE_OPTIONS: JSON.stringify(serveOptions),
+					SERVER: "./server/index.js",
+				},
+			});
+
+			const entry = `${tmp}/index.ts`;
+			if (builder.hasServerInstrumentationFile?.()) {
+				// Instrumentation (OpenTelemetry &c.) has to load before anything
+				// else in the bundle. A compiled binary has no post-build
+				// entrypoint to rewrite, so prepend the import to the compile
+				// entrypoint instead.
+				await Bun.write(
+					entry,
+					`import "./server/instrumentation.server.js";\n${await Bun.file(entry).text()}`,
+				);
+			}
+
+			builder.log.minor(
+				target ? `Compiling executable (${target})` : "Compiling executable",
+			);
+			const outfile = `${out}/${name}`;
+			const result = await Bun.build({
+				entrypoints: [entry],
+				target: "bun",
+				minify,
+				bytecode,
+				sourcemap: sourcemap ? "linked" : "none",
+				compile: {
+					outfile,
+					...(target ? { target } : {}),
+				},
+			});
+
+			if (!result.success) {
+				for (const message of result.logs) {
+					builder.log.error(String(message));
+				}
+				throw new Error("`bun build --compile` failed");
+			}
+
+			builder.log.success(`Compiled ${outfile}`);
+		},
+	};
+}

package/internal.d.ts

@@ -0,0 +1,38 @@
+// Ambient declarations for the virtual specifiers/globals `templates/*.ts`
+// reference. None of these are real modules or runtime globals at
+// type-check time, `index.ts`'s adapt() resolves them via a raw text
+// replacement over the compiled output (see its `builder.copy(..., {
+// replace })` call), so this file exists purely so `templates/*.ts`
+// typechecks against the shape that replacement actually produces.
+
+declare module "ENV" {
+	export function env(name: string, fallback: string): string;
+	export function env(name: string, fallback: false): string | false;
+	export function env(name: string, fallback?: undefined): string | undefined;
+}
+
+declare module "HANDLER" {
+	export function getHandler(): {
+		fetch: (
+			request: Request,
+			server: Bun.Server<undefined>,
+		) => Response | Promise<Response>;
+		websocket: Bun.WebSocketHandler<undefined> | undefined;
+	};
+}
+
+declare module "MANIFEST" {
+	import type { SSRManifest } from "@sveltejs/kit";
+
+	export const base: string;
+	export const manifest: SSRManifest;
+	export const prerendered: Set<string>;
+}
+
+declare module "SERVER" {
+	export { Server } from "@sveltejs/kit";
+}
+
+declare const ENV_PREFIX: string;
+declare const BUILD_OPTIONS: { serveAssets: boolean; precompress: boolean };
+declare const SERVE_OPTIONS: Record<string, unknown>;

package/package.json

@@ -0,0 +1,55 @@
+{
+	"name": "@orochibraru/svelte-smol",
+	"version": "1.3.0",
+	"type": "module",
+	"main": "./index.ts",
+	"module": "./index.ts",
+	"types": "./index.ts",
+	"author": {
+		"email": "orochibraru@gmail.com",
+		"name": "orochibraru"
+	},
+	"exports": {
+		".": "./index.ts"
+	},
+	"files": [
+		"index.ts",
+		"internal.d.ts",
+		"templates"
+	],
+	"repository": {
+		"type": "git",
+		"url": "https://github.coms/orochibraru/svelte-smol.git"
+	},
+	"publishConfig": {
+		"access": "public"
+	},
+	"scripts": {
+		"typecheck": "tsc --noEmit -p tsconfig.json",
+		"test": "bun test index.test.ts",
+		"test:integration": "bun test test/integration.test.ts",
+		"lint": "biome check .",
+		"lint:fix": "biome check --write .",
+		"release": "semantic-release",
+		"release:dry": "semantic-release --dry-run --no-ci",
+		"prepare": "husky"
+	},
+	"devDependencies": {
+		"@biomejs/biome": "^2.5.11",
+		"@saithodev/semantic-release-gitea": "^2.1.0",
+		"@semantic-release/changelog": "^7.0.0",
+		"@semantic-release/git": "^11.0.1",
+		"@semantic-release/npm": "^13.1.5",
+		"@sveltejs/kit": "^2.70.3",
+		"@sveltejs/vite-plugin-svelte": "^7.3.0",
+		"@types/bun": "^1.4.0",
+		"husky": "^9.1.7",
+		"semantic-release": "^25.0.9",
+		"svelte": "^5.56.10",
+		"typescript": "^7",
+		"vite": "^8.2.2"
+	},
+	"peerDependencies": {
+		"@sveltejs/kit": "^2.0.0"
+	}
+}

package/templates/env.ts

@@ -0,0 +1,38 @@
+/* global ENV_PREFIX */
+
+const expected = new Set([
+	"SOCKET_PATH",
+	"HOST",
+	"PORT",
+	"ASSETS_DIR",
+	"ORIGIN",
+	"XFF_DEPTH",
+	"ADDRESS_HEADER",
+	"PROTOCOL_HEADER",
+	"HOST_HEADER",
+	"PORT_HEADER",
+	"BODY_SIZE_LIMIT",
+	"IDLE_TIMEOUT",
+	"SHUTDOWN_TIMEOUT",
+]);
+
+if (ENV_PREFIX) {
+	for (const name in Bun.env) {
+		if (name.startsWith(ENV_PREFIX)) {
+			const unprefixed = name.slice(ENV_PREFIX.length);
+			if (!expected.has(unprefixed)) {
+				throw new Error(
+					`You should change envPrefix (${ENV_PREFIX}) to avoid conflicts with existing environment variables — unexpectedly saw ${name}`,
+				);
+			}
+		}
+	}
+}
+
+export function env(name: string, fallback: string): string;
+export function env(name: string, fallback: false): string | false;
+export function env(name: string, fallback?: undefined): string | undefined;
+export function env(name: string, fallback?: string | false) {
+	const prefixed = ENV_PREFIX + name;
+	return prefixed in Bun.env ? Bun.env[prefixed] : fallback;
+}

package/templates/handler.ts

@@ -0,0 +1,215 @@
+/* global ENV_PREFIX, BUILD_OPTIONS */
+
+import { env } from "ENV";
+import { base, manifest, prerendered } from "MANIFEST";
+import { Server } from "SERVER";
+import { statSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import type { Server as SvelteKitServer } from "@sveltejs/kit";
+
+const server = new Server(manifest) as SvelteKitServer & {
+	websocket?: () => Bun.WebSocketHandler<undefined> | undefined;
+};
+
+const { serveAssets, precompress } = BUILD_OPTIONS;
+
+const origin = env("ORIGIN", undefined);
+const xff_depth = Number.parseInt(env("XFF_DEPTH", "1"), 10);
+const address_header = env("ADDRESS_HEADER", "").toLowerCase();
+const protocol_header = env("PROTOCOL_HEADER", "").toLowerCase();
+const host_header = env("HOST_HEADER", "").toLowerCase();
+const port_header = env("PORT_HEADER", "").toLowerCase();
+
+// Static assets and prerendered pages are deployed next to the executable:
+//   <dir>/<binary>
+//   <dir>/client/…
+//   <dir>/prerendered/…
+// `ASSETS_DIR` overrides that parent directory (absolute, or relative to the
+// binary). `import.meta.dir` is a virtual path inside a compiled binary, so
+// the real on-disk location comes from `process.execPath`.
+const assets_root = resolve(dirname(process.execPath), env("ASSETS_DIR", ""));
+const client_dir = `${assets_root}/client${base}`;
+const prerendered_dir = `${assets_root}/prerendered${base}`;
+const immutable_prefix = `${base}/${manifest.appDir}/immutable/`;
+
+await server.init({
+	env: Bun.env as Record<string, string>,
+	read: (file) => Bun.file(`${client_dir}/${file}`).stream(),
+});
+
+// Pre-compressed sibling files, tried in this order when `precompress` is on.
+const encodings: Array<readonly [token: string, ext: string]> = precompress
+	? [
+			["br", ".br"],
+			["gzip", ".gz"],
+		]
+	: [];
+
+/** `statSync` that yields `undefined` for a missing path or a non-file. */
+function file_stat(path: string) {
+	try {
+		const stat = statSync(path);
+		return stat.isFile() ? stat : undefined;
+	} catch {
+		return undefined;
+	}
+}
+
+function asset_response(
+	file: string,
+	request: Request,
+	immutable = false,
+): Response | undefined {
+	let stat = file_stat(file);
+	if (!stat) {
+		return undefined;
+	}
+
+	const headers = new Headers();
+	headers.set(
+		"cache-control",
+		immutable
+			? "public,max-age=31536000,immutable"
+			: "public,max-age=0,must-revalidate",
+	);
+
+	let body = file;
+	const accept = request.headers.get("accept-encoding") ?? "";
+	for (const [token, ext] of encodings) {
+		const compressed = accept.includes(token) && file_stat(`${file}${ext}`);
+		if (compressed) {
+			body = `${file}${ext}`;
+			stat = compressed;
+			headers.set("content-encoding", token);
+			headers.set("vary", "Accept-Encoding");
+			// The compressed sibling has no useful media type of its own.
+			headers.set("content-type", Bun.file(file).type);
+			break;
+		}
+	}
+
+	const { size, mtimeMs } = stat;
+	const etag = `W/"${size.toString(16)}-${Math.round(mtimeMs).toString(16)}"`;
+	if (request.headers.get("if-none-match") === etag) {
+		return new Response(null, { headers, status: 304 });
+	}
+	headers.set("etag", etag);
+
+	return new Response(Bun.file(body), { headers });
+}
+
+function serve_static(url: URL, request: Request): Response | undefined {
+	if (!serveAssets) {
+		return undefined;
+	}
+
+	const { pathname } = url;
+	const rel = pathname.startsWith(base)
+		? pathname.slice(base.length)
+		: pathname;
+
+	if (prerendered.has(pathname)) {
+		const file =
+			rel === "/" || rel === ""
+				? "index.html"
+				: rel.endsWith("/")
+					? `${rel.slice(1)}index.html`
+					: `${rel.slice(1)}.html`;
+		return asset_response(`${prerendered_dir}/${file}`, request);
+	}
+
+	// The other trailing-slash form of a prerendered path redirects to the
+	// canonical one, query string preserved (matches SvelteKit's own
+	// trailingSlash handling).
+	const toggled = pathname.endsWith("/")
+		? pathname.slice(0, -1)
+		: `${pathname}/`;
+	if (prerendered.has(toggled)) {
+		return new Response(null, {
+			headers: { location: toggled + url.search },
+			status: 308,
+		});
+	}
+
+	return asset_response(
+		`${client_dir}/${rel.slice(1)}`,
+		request,
+		pathname.startsWith(immutable_prefix),
+	);
+}
+
+const ssr = async (request: Request, bunServer: Bun.Server<undefined>) => {
+	const url = new URL(request.url);
+
+	const asset = serve_static(url, request);
+	if (asset) {
+		return asset;
+	}
+
+	const baseOrigin = origin || get_origin(request.headers);
+	const path = request.url.slice(request.url.split("/", 3).join("/").length);
+	const newRequest = new Request(baseOrigin + path, request);
+
+	const response = await server.respond(newRequest, {
+		getClientAddress() {
+			if (address_header) {
+				if (!request.headers.has(address_header)) {
+					throw new Error(
+						`Address header was specified with ${`${ENV_PREFIX}ADDRESS_HEADER`}=${address_header} but is absent from request`,
+					);
+				}
+
+				const value = request.headers.get(address_header) || "";
+
+				if (address_header === "x-forwarded-for") {
+					const addresses = value.split(",");
+
+					if (xff_depth < 1) {
+						throw new Error(
+							`${`${ENV_PREFIX}XFF_DEPTH`} must be a positive integer`,
+						);
+					}
+
+					if (xff_depth > addresses.length) {
+						throw new Error(
+							`${`${ENV_PREFIX}XFF_DEPTH`} is ${xff_depth}, but only found ${addresses.length} addresses`,
+						);
+					}
+					return addresses[addresses.length - xff_depth]?.trim() || "";
+				}
+
+				return value;
+			}
+
+			return bunServer.requestIP(request)?.address || "";
+		},
+		platform: { request, server: bunServer },
+	});
+
+	// SvelteKit streams Server-Sent Events with no Content-Length and long
+	// gaps between writes; Bun's idleTimeout (default 10s) would sever the
+	// connection between events. Disable it for the life of this response.
+	if (response.headers.get("content-type")?.startsWith("text/event-stream")) {
+		bunServer.timeout(request, 0);
+	}
+
+	return response;
+};
+
+export const getHandler = () => {
+	const websocket =
+		typeof server.websocket === "function" ? server.websocket() : undefined;
+
+	return {
+		fetch: ssr,
+		websocket,
+	};
+};
+
+function get_origin(headers: Headers) {
+	const protocol = (protocol_header && headers.get(protocol_header)) || "https";
+	const host = (host_header && headers.get(host_header)) || headers.get("host");
+	const port = port_header && headers.get(port_header);
+
+	return port ? `${protocol}://${host}:${port}` : `${protocol}://${host}`;
+}

package/templates/index.ts

@@ -0,0 +1,76 @@
+import { env } from "ENV";
+import { getHandler } from "HANDLER";
+import process from "node:process";
+
+export const path = env("SOCKET_PATH", false);
+export const host = env("HOST", "0.0.0.0");
+export const port = env("PORT", "3000");
+
+const body_size_limit = parse_as_bytes(env("BODY_SIZE_LIMIT", "512K"));
+if (Number.isNaN(body_size_limit)) {
+	throw new Error(
+		`Invalid BODY_SIZE_LIMIT: '${env("BODY_SIZE_LIMIT", "512K")}'. Please provide a numeric value.`,
+	);
+}
+
+const idle_timeout = Number.parseInt(env("IDLE_TIMEOUT", "10"), 10);
+const { fetch: handlerFetch, websocket } = getHandler();
+
+const options = {
+	...SERVE_OPTIONS,
+	fetch: handlerFetch,
+	idleTimeout: idle_timeout,
+	maxRequestBodySize: body_size_limit,
+	...(path ? { unix: path } : { hostname: host, port: port }),
+	...(websocket ? { websocket } : {}),
+};
+
+const server = Bun.serve(options as Parameters<typeof Bun.serve>[0]);
+
+console.log(`Listening on ${server.url} ${websocket ? "with WebSocket" : ""}`);
+
+const shutdown_timeout_ms =
+	Number.parseInt(env("SHUTDOWN_TIMEOUT", "30"), 10) * 1000;
+let shutting_down = false;
+
+async function graceful_shutdown(reason: "SIGINT" | "SIGTERM" | "IDLE") {
+	if (shutting_down) {
+		console.info(`Received ${reason} again, forcing immediate shutdown.`);
+		process.exit(1);
+	}
+	shutting_down = true;
+
+	console.info(
+		`Stopping server (waiting up to ${shutdown_timeout_ms / 1000}s for in-flight requests to finish)...`,
+	);
+	process.emit("sveltekit:shutdown", reason);
+
+	const force_timer = setTimeout(() => {
+		console.warn(
+			`Graceful shutdown exceeded ${shutdown_timeout_ms / 1000}s, forcing.`,
+		);
+		server.stop(true).finally(() => process.exit(1));
+	}, shutdown_timeout_ms);
+
+	await server.stop();
+	clearTimeout(force_timer);
+	console.info("Stopped server");
+	process.exit(0);
+}
+
+process.on("SIGTERM", graceful_shutdown);
+process.on("SIGINT", graceful_shutdown);
+
+export { server };
+
+function parse_as_bytes(value: string): number {
+	const units = value.at(-1)?.toUpperCase();
+	const multiplier =
+		{
+			B: 1,
+			G: 1024 * 1024 * 1024,
+			K: 1024,
+			M: 1024 * 1024,
+		}[units ?? "B"] ?? 1;
+	return Number(multiplier !== 1 ? value.slice(0, -1) : value) * multiplier;
+}