@orochibraru/svelte-smol 1.4.0 → 1.5.1

package/README.md

@@ -46,12 +46,40 @@ 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/
+```
+
+```bash
+bun run ./build/index.js
+```
+
+Pure-JS dependencies are still bundled into `index.js`. A native addon can't be,
+so its `require` stays in the output and resolves from `node_modules` at runtime
+(looked up from `index.js`'s own location, so the working directory doesn't
+matter). Ship `node_modules` for those — a production install is enough, since
+everything that got bundled needn't be there.
+
+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,23 @@ 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 `build/index.js`
+	 * bundle instead, run with `bun run build/index.js`. Pure-JS dependencies
+	 * are still bundled in; a native (`.node`) addon can't be, so it resolves
+	 * from `node_modules` at runtime — which a `bun` process can do and a
+	 * compiled binary can't. This is the only way to ship `sharp`, `sqlite3`
+	 * and the like. 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 +109,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 (run with `bun`), the only way to ship a
+ * native (`.node`) addon.
+ *
  * Output, all written to {@link AdapterOptions.out | `out`}:
  *
  * ```text
@@ -140,6 +157,7 @@ export default function adapter(options: AdapterOptions = {}): Adapter {
 	const {
 		out = "build",
 		name = "server",
+		compile = true,
 		target,
 		bytecode = false,
 		minify = false,
@@ -209,6 +227,7 @@ export default function adapter(options: AdapterOptions = {}): Adapter {
 						serveAssets,
 						precompress,
 						healthcheck: healthcheckConfig,
+						compiled: compile,
 					}),
 					ENV: "./env.ts",
 					ENV_PREFIX: JSON.stringify(envPrefix),
@@ -231,35 +250,69 @@ 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");
+				// Same bundle as the compiled binary, just emitted as a file. Every
+				// pure-JS dependency is inlined; a native (`.node`) addon can't be,
+				// so its `require` stays in the output and resolves from
+				// `node_modules` at runtime — which is exactly what a plain `bun`
+				// process (unlike a compiled binary) can do. Ship `node_modules`
+				// for those; anything fully bundled needn't be installed.
+				check(
+					await Bun.build({
+						entrypoints: [entrypoint],
+						target: "bun",
+						format: "esm",
+						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,6 +1,6 @@
 {
 	"name": "@orochibraru/svelte-smol",
-	"version": "1.4.0",
+	"version": "1.5.1",
 	"type": "module",
 	"main": "./index.ts",
 	"keywords": [

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/`;