@orochibraru/svelte-smol 1.3.1 → 1.3.2

package/README.md

@@ -2,19 +2,19 @@
 
 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.
+no JS files to ship, just one binary plus its static assets.
 
 ## Install
 
 ```bash
-bun add -d @orochibraru/svelte-adapter-bun
+bun add -d @orochibraru/svelte-smol
 ```
 
 ## Usage
 
 ```js
 // svelte.config.js
-import adapter from "@orochibraru/svelte-smol;
+import adapter from "@orochibraru/svelte-smol";
 
 export default {
   kit: {
@@ -23,11 +23,10 @@ export default {
 };
 ```
 
-Because the adapter touches `Bun.*` at config-load time, run the build with the
-Bun runtime:
+The compile step runs under the Bun runtime, so build with:
 
 ```bash
-bun --bun vite build
+bun run vite build
 ```
 
 ## Output
@@ -40,7 +39,7 @@ build/
 ```
 
 Deploy the whole `build/` directory (or just `server` if a proxy/CDN serves the
-assets — see `serveAssets`). The executable locates `client/` and `prerendered/`
+assets, see `serveAssets`). The executable locates `client/` and `prerendered/`
 relative to its own path, so it can be run from any working directory:
 
 ```bash
@@ -58,6 +57,7 @@ adapter({
   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
+  healthcheck: true, // also compile `build/healthcheck` + expose GET /_health
   envPrefix: "", // prefix for the runtime env vars below
   serveAssets: true, // serve client/ and prerendered/ from the binary
   serveOptions: {}, // extra Bun.serve() options (tls, reusePort, …)
@@ -88,9 +88,27 @@ runtime the first time you use a target.
 | `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`                                    |
+| `HEALTHCHECK_PATH` | `/_health`| Endpoint the `healthcheck` binary probes (must match the `healthcheck` option)                  |
+| `HEALTHCHECK_TIMEOUT` | `2000` | `healthcheck` binary request timeout in ms                                                     |
 
 Set `envPrefix` to namespace these (`envPrefix: "MY_APP_"` → `MY_APP_PORT`).
 
+## Health check
+
+With `healthcheck` enabled (the default) the build also produces
+`build/healthcheck` — a tiny executable that requests `GET /_health` over
+loopback (or the Unix socket) and exits `0` when the server answers `200`,
+`1` otherwise. `GET /_health` returns `{ "status": "ok", uptime, rss, pid,
+timestamp }`. Drop it straight into Docker:
+
+```dockerfile
+HEALTHCHECK --interval=30s --timeout=5s --start-period=5s --retries=3 \
+	CMD ["./build/healthcheck"]
+```
+
+It reads the same `HOST` / `PORT` / `SOCKET_PATH` as the server, so no extra
+wiring is needed.
+
 ## Notes
 
 - The SvelteKit server code is JavaScript emitted by Vite; `--compile` embeds it
@@ -98,3 +116,14 @@ Set `envPrefix` to namespace these (`envPrefix: "MY_APP_"` → `MY_APP_PORT`).
   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.
+
+## Releases
+
+Automated by [semantic-release](https://semantic-release.gitbook.io/) from
+[Conventional Commits](https://www.conventionalcommits.org/):
+
+- `fix:` / `perf:` → **patch**, `feat:` → **minor**, `feat!:` or a
+  `BREAKING CHANGE:` footer → **major**
+- `docs:` `refactor:` `test:` `chore:` `build:` `ci:` `style:` → **no release**
+- `feat:` / `fix:` scoped to `ci`, `build`, `deps`, `dev`, `repo`, `test`,
+  `example`, `release` → **no release** (they don't touch the published package)

package/index.ts

@@ -44,6 +44,15 @@ export interface AdapterOptions {
 	 * @default false
 	 */
 	precompress?: boolean;
+	/**
+	 * Compile a second tiny executable, `healthcheck`, alongside the server
+	 * and expose a matching `GET` endpoint. The binary probes that endpoint
+	 * over loopback (or the Unix socket) and exits `0` when healthy, `1`
+	 * otherwise — ready to drop into a Docker `HEALTHCHECK`. Pass an object
+	 * to change the endpoint path.
+	 * @default true
+	 */
+	healthcheck?: boolean | { path?: string };
 	/**
 	 * Prefix for this adapter's own runtime env vars (`PORT`, `HOST`,
 	 * `ORIGIN`, ...).
@@ -112,7 +121,7 @@ const templates = fileURLToPath(new URL("./templates", import.meta.url));
  * @example
  * ```js
  * // svelte.config.js
- * import adapter from "@orochibraru/svelte-smol;
+ * import adapter from "@orochibraru/svelte-smol";
  *
  * export default {
  *   kit: {
@@ -136,13 +145,22 @@ export default function adapter(options: AdapterOptions = {}): Adapter {
 		minify = false,
 		sourcemap = false,
 		precompress = false,
+		healthcheck = true,
 		envPrefix = "",
 		serveAssets = true,
 		serveOptions = {},
 	} = options;
 
+	const healthcheckConfig =
+		healthcheck === false
+			? false
+			: {
+					path:
+						(healthcheck === true ? undefined : healthcheck.path) ?? "/_health",
+				};
+
 	return {
-		name: "homerun-svelte-adapter-bun",
+		name: "@orochibraru/svelte-smol",
 		supports: {
 			instrumentation: () => true,
 			read: () => true,
@@ -187,7 +205,11 @@ export default function adapter(options: AdapterOptions = {}): Adapter {
 			builder.log.minor("Copying entrypoint");
 			builder.copy(templates, tmp, {
 				replace: {
-					BUILD_OPTIONS: JSON.stringify({ serveAssets, precompress }),
+					BUILD_OPTIONS: JSON.stringify({
+						serveAssets,
+						precompress,
+						healthcheck: healthcheckConfig,
+					}),
 					ENV: "./env.ts",
 					ENV_PREFIX: JSON.stringify(envPrefix),
 					HANDLER: "./handler.ts",
@@ -209,30 +231,36 @@ export default function adapter(options: AdapterOptions = {}): Adapter {
 				);
 			}
 
-			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 } : {}),
-				},
-			});
+			const compile = async (entrypoint: string, outName: string) => {
+				builder.log.minor(
+					target ? `Compiling ${outName} (${target})` : `Compiling ${outName}`,
+				);
+				const result = await Bun.build({
+					entrypoints: [entrypoint],
+					target: "bun",
+					minify,
+					bytecode,
+					sourcemap: sourcemap ? "linked" : "none",
+					compile: {
+						outfile: `${out}/${outName}`,
+						...(target ? { target } : {}),
+					},
+				});
 
-			if (!result.success) {
-				for (const message of result.logs) {
-					builder.log.error(String(message));
+				if (!result.success) {
+					for (const message of result.logs) {
+						builder.log.error(String(message));
+					}
+					throw new Error(`\`bun build --compile\` failed for ${outName}`);
 				}
-				throw new Error("`bun build --compile` failed");
-			}
 
-			builder.log.success(`Compiled ${outfile}`);
+				builder.log.success(`Compiled ${out}/${outName}`);
+			};
+
+			await compile(entry, name);
+			if (healthcheckConfig) {
+				await compile(`${tmp}/healthcheck.ts`, "healthcheck");
+			}
 		},
 	};
 }

package/internal.d.ts

@@ -34,5 +34,9 @@ declare module "SERVER" {
 }
 
 declare const ENV_PREFIX: string;
-declare const BUILD_OPTIONS: { serveAssets: boolean; precompress: boolean };
+declare const BUILD_OPTIONS: {
+	serveAssets: boolean;
+	precompress: boolean;
+	healthcheck: false | { path: string };
+};
 declare const SERVE_OPTIONS: Record<string, unknown>;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@orochibraru/svelte-smol",
-	"version": "1.3.1",
+	"version": "1.3.2",
 	"type": "module",
 	"main": "./index.ts",
 	"module": "./index.ts",
@@ -19,7 +19,7 @@
 	],
 	"repository": {
 		"type": "git",
-		"url": "https://github.coms/orochibraru/svelte-smol.git"
+		"url": "git+https://github.com/orochibraru/svelte-smol.git"
 	},
 	"publishConfig": {
 		"access": "public"
@@ -36,13 +36,14 @@
 	},
 	"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/github": "^12.0.9",
 		"@semantic-release/npm": "^13.1.5",
 		"@sveltejs/kit": "^2.70.3",
 		"@sveltejs/vite-plugin-svelte": "^7.3.0",
 		"@types/bun": "^1.4.0",
+		"conventional-changelog-conventionalcommits": "^10.4.0",
 		"husky": "^9.1.7",
 		"semantic-release": "^25.0.9",
 		"svelte": "^5.56.10",

package/templates/env.ts

@@ -14,6 +14,8 @@ const expected = new Set([
 	"BODY_SIZE_LIMIT",
 	"IDLE_TIMEOUT",
 	"SHUTDOWN_TIMEOUT",
+	"HEALTHCHECK_PATH",
+	"HEALTHCHECK_TIMEOUT",
 ]);
 
 if (ENV_PREFIX) {

package/templates/handler.ts

@@ -11,7 +11,7 @@ const server = new Server(manifest) as SvelteKitServer & {
 	websocket?: () => Bun.WebSocketHandler<undefined> | undefined;
 };
 
-const { serveAssets, precompress } = BUILD_OPTIONS;
+const { serveAssets, precompress, healthcheck } = BUILD_OPTIONS;
 
 const origin = env("ORIGIN", undefined);
 const xff_depth = Number.parseInt(env("XFF_DEPTH", "1"), 10);
@@ -141,6 +141,23 @@ function serve_static(url: URL, request: Request): Response | undefined {
 const ssr = async (request: Request, bunServer: Bun.Server<undefined>) => {
 	const url = new URL(request.url);
 
+	if (
+		healthcheck &&
+		request.method === "GET" &&
+		url.pathname === healthcheck.path
+	) {
+		return Response.json(
+			{
+				status: "ok",
+				uptime: Math.round(process.uptime()),
+				rss: process.memoryUsage.rss(),
+				pid: process.pid,
+				timestamp: new Date().toISOString(),
+			},
+			{ headers: { "cache-control": "no-store" } },
+		);
+	}
+
 	const asset = serve_static(url, request);
 	if (asset) {
 		return asset;

package/templates/healthcheck.ts

@@ -0,0 +1,55 @@
+/* global BUILD_OPTIONS */
+
+import { env } from "ENV";
+import process from "node:process";
+
+const { healthcheck } = BUILD_OPTIONS;
+
+if (!healthcheck) {
+	console.error("healthcheck is disabled for this build");
+	process.exit(2);
+}
+
+const socket = env("SOCKET_PATH", false);
+const timeout_ms = Number.parseInt(env("HEALTHCHECK_TIMEOUT", "2000"), 10);
+const path = env("HEALTHCHECK_PATH", healthcheck.path);
+
+// A server bound to a wildcard address is reached over loopback.
+const raw_host = env("HOST", "0.0.0.0");
+const host =
+	raw_host === "0.0.0.0" || raw_host === "::" || raw_host === ""
+		? "127.0.0.1"
+		: raw_host;
+const port = env("PORT", "3000");
+
+const url = socket
+	? `http://localhost${path}`
+	: `http://${host.includes(":") ? `[${host}]` : host}:${port}${path}`;
+
+function fail(reason: string): never {
+	console.error(`unhealthy: ${reason}`);
+	process.exit(1);
+}
+
+try {
+	const response = await fetch(url, {
+		headers: { "user-agent": "svelte-smol-healthcheck" },
+		signal: AbortSignal.timeout(timeout_ms),
+		...(socket ? { unix: socket } : {}),
+	});
+
+	if (!response.ok) {
+		fail(`${url} -> ${response.status}`);
+	}
+
+	const body = (await response.json().catch(() => null)) as {
+		status?: string;
+	} | null;
+	if (body?.status && body.status !== "ok") {
+		fail(`status=${body.status}`);
+	}
+
+	process.exit(0);
+} catch (error) {
+	fail(`${url} -> ${error instanceof Error ? error.message : String(error)}`);
+}

package/templates/index.ts

@@ -25,12 +25,26 @@ const options = {
 	...(websocket ? { websocket } : {}),
 };
 
+const shutdown_timeout_ms =
+	Number.parseInt(env("SHUTDOWN_TIMEOUT", "30"), 10) * 1000;
+
 const server = Bun.serve(options as Parameters<typeof Bun.serve>[0]);
 
-console.log(`Listening on ${server.url} ${websocket ? "with WebSocket" : ""}`);
+const rows: Array<[string, string]> = [
+	["Listening on", path ? `unix:${path}` : `${server.url}`],
+	["WebSocket", websocket ? "enabled" : "disabled"],
+	["Body limit", format_bytes(body_size_limit)],
+	["Idle timeout", `${idle_timeout}s`],
+	["Shutdown grace", `${shutdown_timeout_ms / 1000}s`],
+	["Runtime", `Bun ${Bun.version} (${process.platform}/${process.arch})`],
+	["PID", `${process.pid}`],
+];
+console.log(
+	`\n  SvelteKit server ready\n\n${rows
+		.map(([label, value]) => `  ${`${label}:`.padEnd(16)}${value}`)
+		.join("\n")}\n`,
+);
 
-const shutdown_timeout_ms =
-	Number.parseInt(env("SHUTDOWN_TIMEOUT", "30"), 10) * 1000;
 let shutting_down = false;
 
 async function graceful_shutdown(reason: "SIGINT" | "SIGTERM" | "IDLE") {
@@ -74,3 +88,14 @@ function parse_as_bytes(value: string): number {
 		}[units ?? "B"] ?? 1;
 	return Number(multiplier !== 1 ? value.slice(0, -1) : value) * multiplier;
 }
+
+function format_bytes(bytes: number): string {
+	const units = ["B", "KB", "MB", "GB"];
+	let value = bytes;
+	let unit = 0;
+	while (value >= 1024 && unit < units.length - 1) {
+		value /= 1024;
+		unit++;
+	}
+	return `${Number.isInteger(value) ? value : value.toFixed(1)} ${units[unit]}`;
+}