@orochibraru/svelte-smol 1.3.2 → 1.5.0

package/README.md

@@ -46,12 +46,37 @@ relative to its own path, so it can be run from any working directory:
 ./build/server
 ```
 
+### `compile: false`
+
+`bun build --compile` bundles every dependency into the binary, and a native
+(`.node`) addon like `sharp` or `better-sqlite3` can't be bundled that way. Set
+`compile: false` to emit a plain bundle instead:
+
+```text
+build/
+├── index.js       # the server bundle, run with `bun`
+├── healthcheck    # still a compiled binary
+├── client/
+└── prerendered/
+```
+
+Dependencies stay external, so ship `node_modules` next to `build/` (or anywhere
+up the tree) and start it with:
+
+```bash
+bun run ./build/index.js
+```
+
+Everything else — env vars, the `healthcheck` binary, `serveAssets`,
+instrumentation — works the same.
+
 ## Options
 
 ```js
 adapter({
   out: "build", // output directory
   name: "server", // executable filename within `out`
+  compile: true, // false → emit build/index.js (run with `bun`) instead of a binary
   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

package/index.ts

@@ -9,10 +9,22 @@ export interface AdapterOptions {
 	 */
 	out?: string;
 	/**
-	 * Filename of the compiled executable, written into `out`.
+	 * Filename of the compiled executable, written into `out`. Ignored when
+	 * {@link AdapterOptions.compile | `compile`} is `false` (the server bundle
+	 * is always `index.js` then).
 	 * @default "server"
 	 */
 	name?: string;
+	/**
+	 * Compile the server to a single standalone executable with
+	 * `bun build --compile`. Turn this off to emit a plain `index.js` bundle
+	 * instead, run with `bun run build/index.js` alongside a `node_modules`
+	 * directory — the only way to ship a dependency with a native (`.node`)
+	 * addon that `bun build --compile` can't embed (`sharp`, `sqlite3`, …).
+	 * The `healthcheck` binary is still compiled either way.
+	 * @default true
+	 */
+	compile?: boolean;
 	/**
 	 * Cross-compilation target for `bun build --compile`, e.g.
 	 * `"bun-linux-x64"`, `"bun-linux-arm64-musl"`, `"bun-darwin-arm64"`,
@@ -96,6 +108,10 @@ const templates = fileURLToPath(new URL("./templates", import.meta.url));
  * Bun runtime (`bun --bun vite build`, or a `bunfig.toml` with `[run] bun =
  * true`); loading the config alone works under Node too.
  *
+ * With {@link AdapterOptions.compile | `compile: false`} it emits a plain
+ * `build/index.js` bundle instead (dependencies external, run with `bun`),
+ * which is the only way to ship a native (`.node`) addon.
+ *
  * Output, all written to {@link AdapterOptions.out | `out`}:
  *
  * ```text
@@ -140,6 +156,7 @@ export default function adapter(options: AdapterOptions = {}): Adapter {
 	const {
 		out = "build",
 		name = "server",
+		compile = true,
 		target,
 		bytecode = false,
 		minify = false,
@@ -209,6 +226,7 @@ export default function adapter(options: AdapterOptions = {}): Adapter {
 						serveAssets,
 						precompress,
 						healthcheck: healthcheckConfig,
+						compiled: compile,
 					}),
 					ENV: "./env.ts",
 					ENV_PREFIX: JSON.stringify(envPrefix),
@@ -231,35 +249,68 @@ export default function adapter(options: AdapterOptions = {}): Adapter {
 				);
 			}
 
-			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 } : {}),
-					},
-				});
-
+			const check = (
+				result: Awaited<ReturnType<typeof Bun.build>>,
+				label: string,
+			) => {
 				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\` failed for ${label}`);
 				}
+			};
 
+			const compileBinary = async (entrypoint: string, outName: string) => {
+				builder.log.minor(
+					target ? `Compiling ${outName} (${target})` : `Compiling ${outName}`,
+				);
+				check(
+					await Bun.build({
+						entrypoints: [entrypoint],
+						target: "bun",
+						minify,
+						bytecode,
+						sourcemap: sourcemap ? "linked" : "none",
+						compile: {
+							outfile: `${out}/${outName}`,
+							...(target ? { target } : {}),
+						},
+					}),
+					outName,
+				);
 				builder.log.success(`Compiled ${out}/${outName}`);
 			};
 
-			await compile(entry, name);
+			const bundleServer = async (entrypoint: string) => {
+				builder.log.minor("Bundling index.js");
+				// `packages: "external"` keeps every `node_modules` dependency out
+				// of the bundle so it resolves from disk at runtime — that is what
+				// lets native (`.node`) addons work, which is the whole point of
+				// skipping `--compile`. Ship `node_modules` next to `build/`.
+				check(
+					await Bun.build({
+						entrypoints: [entrypoint],
+						target: "bun",
+						format: "esm",
+						packages: "external",
+						minify,
+						sourcemap: sourcemap ? "linked" : "none",
+						outdir: out,
+						naming: "index.js",
+					}),
+					"index.js",
+				);
+				builder.log.success(`Bundled ${out}/index.js`);
+			};
+
+			if (compile) {
+				await compileBinary(entry, name);
+			} else {
+				await bundleServer(entry);
+			}
 			if (healthcheckConfig) {
-				await compile(`${tmp}/healthcheck.ts`, "healthcheck");
+				await compileBinary(`${tmp}/healthcheck.ts`, "healthcheck");
 			}
 		},
 	};

package/internal.d.ts

@@ -38,5 +38,6 @@ declare const BUILD_OPTIONS: {
 	serveAssets: boolean;
 	precompress: boolean;
 	healthcheck: false | { path: string };
+	compiled: boolean;
 };
 declare const SERVE_OPTIONS: Record<string, unknown>;

package/package.json

@@ -1,8 +1,15 @@
 {
 	"name": "@orochibraru/svelte-smol",
-	"version": "1.3.2",
+	"version": "1.5.0",
 	"type": "module",
 	"main": "./index.ts",
+	"keywords": [
+		"bun",
+		"svelte",
+		"sveltekit",
+		"adapter",
+		"typescript"
+	],
 	"module": "./index.ts",
 	"types": "./index.ts",
 	"author": {
@@ -36,14 +43,12 @@
 	},
 	"devDependencies": {
 		"@biomejs/biome": "^2.5.11",
-		"@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",
+		"conventional-changelog-conventionalcommits": "^8",
 		"husky": "^9.1.7",
 		"semantic-release": "^25.0.9",
 		"svelte": "^5.56.10",

package/templates/handler.ts

@@ -11,7 +11,7 @@ const server = new Server(manifest) as SvelteKitServer & {
 	websocket?: () => Bun.WebSocketHandler<undefined> | undefined;
 };
 
-const { serveAssets, precompress, healthcheck } = BUILD_OPTIONS;
+const { serveAssets, precompress, healthcheck, compiled } = BUILD_OPTIONS;
 
 const origin = env("ORIGIN", undefined);
 const xff_depth = Number.parseInt(env("XFF_DEPTH", "1"), 10);
@@ -20,14 +20,17 @@ 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>
+// Static assets and prerendered pages are deployed next to the server:
+//   <dir>/<server>
 //   <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", ""));
+// `ASSETS_DIR` overrides that parent directory (absolute, or relative to it).
+// In a compiled binary `import.meta.dir` is a virtual path, so the real
+// on-disk location comes from `process.execPath`; in a plain `index.js`
+// bundle `process.execPath` is the `bun` binary, so `import.meta.dir` (the
+// `build/` directory) is the one that's right.
+const self_dir = compiled ? dirname(process.execPath) : import.meta.dir;
+const assets_root = resolve(self_dir, env("ASSETS_DIR", ""));
 const client_dir = `${assets_root}/client${base}`;
 const prerendered_dir = `${assets_root}/prerendered${base}`;
 const immutable_prefix = `${base}/${manifest.appDir}/immutable/`;