@moku-labs/web 0.1.0-alpha.1

package/dist/bin/moku.mjs

@@ -0,0 +1,809 @@
+#!/usr/bin/env bun
+import { existsSync, readFileSync, statSync, watch } from "node:fs";
+import { extname, normalize, resolve, sep } from "node:path";
+import { parseArgs } from "node:util";
+
+//#region src/bin/help.ts
+/** @file Help text and banner formatters for the moku CLI. */
+/**
+* Format the banner line shown before any output.
+*
+* @param version - The package version.
+* @returns The banner string.
+*/
+const formatBanner = (version) => `moku v${version}`;
+/**
+* Format the top-level help text listing all commands and global flags.
+*
+* @returns The help text.
+*/
+const formatHelp = () => `
+Usage: moku <command> [options]
+
+Commands:
+  build [folder]    Build static site (default folder: src/)
+  dev [folder]      Start dev server with watch + rebuild
+  preview [folder]  Build and serve site for local preview
+
+Options:
+  --version         Show version number
+  --help, -h        Show help
+
+Run moku <command> --help for command-specific options.`.trim();
+/**
+* Format the help text for `moku build`.
+*
+* @returns The help text.
+*/
+const formatBuildHelp = () => `
+Usage: moku build [folder] [options]
+
+Arguments:
+  folder            Source folder containing main.ts (default: src/)
+
+Options:
+  --verbose, -v     Show detailed build output
+  --mode <mode>     Build mode: ssg, spa, hybrid
+  --help, -h        Show help`.trim();
+/**
+* Format the help text for `moku dev`.
+*
+* @returns The help text.
+*/
+const formatDevHelp = () => `
+Usage: moku dev [folder] [options]
+
+Arguments:
+  folder            Source folder containing main.ts (default: src/)
+
+Options:
+  --verbose, -v     Show detailed build output
+  --port, -p <n>    Server port (default: 4173)
+  --help, -h        Show help`.trim();
+/**
+* Format the help text for `moku preview`.
+*
+* @returns The help text.
+*/
+const formatPreviewHelp = () => `
+Usage: moku preview [folder] [options]
+
+Arguments:
+  folder            Source folder containing main.ts (default: src/)
+
+Options:
+  --port, -p <n>    Server port (default: 3000)
+  --help, -h        Show help`.trim();
+
+//#endregion
+//#region src/bin/parse.ts
+/** @file Argument parsers for the moku CLI built on node:util parseArgs. */
+const VALID_MODES = new Set([
+	"ssg",
+	"spa",
+	"hybrid"
+]);
+const MIN_PORT = 1;
+const MAX_PORT = 65535;
+const DEFAULT_DEV_PORT = 4173;
+const DEFAULT_PREVIEW_PORT = 3e3;
+/**
+* Classify the top-level invocation into version / help / unknown-flag / command.
+*
+* @param argv - The argv slice (already stripped of `process.argv[0..1]`).
+* @returns A {@link TopLevel} discriminant.
+*/
+const parseTopLevel = (argv) => {
+	if (argv.length === 0) return { kind: "help" };
+	const [first, ...rest] = argv;
+	if (first === void 0) return { kind: "help" };
+	if (first === "--version") return { kind: "version" };
+	if (first === "--help" || first === "-h") return { kind: "help" };
+	if (first.startsWith("-")) return {
+		kind: "unknown-flag",
+		flag: first
+	};
+	return {
+		kind: "command",
+		command: first,
+		rest
+	};
+};
+const parsePort = (value, fallback) => {
+	if (value === void 0) return {
+		ok: true,
+		value: fallback
+	};
+	const port = Number.parseInt(value, 10);
+	if (!Number.isFinite(port) || `${port}` !== value) return {
+		ok: false,
+		message: `Invalid port: ${value}. Must be a number.`
+	};
+	if (port < MIN_PORT || port > MAX_PORT) return {
+		ok: false,
+		message: `Invalid port: ${port}. Must be ${MIN_PORT}-${MAX_PORT}.`
+	};
+	return {
+		ok: true,
+		value: port
+	};
+};
+/**
+* Parse `moku build` arguments.
+*
+* @param argv - Argv after the `build` keyword.
+* @returns A {@link ParseResult} carrying a {@link BuildArgs} or an error message.
+*/
+const parseBuild = (argv) => {
+	try {
+		const { values, positionals } = parseArgs({
+			args: argv,
+			options: {
+				verbose: {
+					type: "boolean",
+					short: "v",
+					default: false
+				},
+				mode: { type: "string" },
+				help: {
+					type: "boolean",
+					short: "h",
+					default: false
+				}
+			},
+			allowPositionals: true,
+			strict: true
+		});
+		if (values.mode !== void 0 && !VALID_MODES.has(values.mode)) return {
+			ok: false,
+			message: `Invalid mode: ${values.mode}. Must be one of: ssg, spa, hybrid.`
+		};
+		const mode = values.mode;
+		return {
+			ok: true,
+			value: {
+				folder: positionals[0] ?? "src",
+				verbose: values.verbose,
+				help: values.help,
+				...mode === void 0 ? {} : { mode }
+			}
+		};
+	} catch (error) {
+		return {
+			ok: false,
+			message: error.message
+		};
+	}
+};
+/**
+* Parse `moku dev` arguments.
+*
+* @param argv - Argv after the `dev` keyword.
+* @returns A {@link ParseResult} carrying a {@link DevArgs} or an error message.
+*/
+const parseDev = (argv) => {
+	try {
+		const { values, positionals } = parseArgs({
+			args: argv,
+			options: {
+				verbose: {
+					type: "boolean",
+					short: "v",
+					default: false
+				},
+				port: {
+					type: "string",
+					short: "p"
+				},
+				help: {
+					type: "boolean",
+					short: "h",
+					default: false
+				}
+			},
+			allowPositionals: true,
+			strict: true
+		});
+		const port = parsePort(values.port, DEFAULT_DEV_PORT);
+		if (!port.ok) return port;
+		return {
+			ok: true,
+			value: {
+				folder: positionals[0] ?? "src",
+				verbose: values.verbose,
+				help: values.help,
+				port: port.value
+			}
+		};
+	} catch (error) {
+		return {
+			ok: false,
+			message: error.message
+		};
+	}
+};
+/**
+* Parse `moku preview` arguments.
+*
+* @param argv - Argv after the `preview` keyword.
+* @returns A {@link ParseResult} carrying a {@link PreviewArgs} or an error message.
+*/
+const parsePreview = (argv) => {
+	try {
+		const { values, positionals } = parseArgs({
+			args: argv,
+			options: {
+				port: {
+					type: "string",
+					short: "p"
+				},
+				help: {
+					type: "boolean",
+					short: "h",
+					default: false
+				}
+			},
+			allowPositionals: true,
+			strict: true
+		});
+		const port = parsePort(values.port, DEFAULT_PREVIEW_PORT);
+		if (!port.ok) return port;
+		return {
+			ok: true,
+			value: {
+				folder: positionals[0] ?? "src",
+				help: values.help,
+				port: port.value
+			}
+		};
+	} catch (error) {
+		return {
+			ok: false,
+			message: error.message
+		};
+	}
+};
+
+//#endregion
+//#region src/bin/version.ts
+const parseSemver = (raw) => {
+	const stripped = raw.split(/[+-]/, 1)[0] ?? raw;
+	const match = /^(\d+)\.(\d+)\.(\d+)$/.exec(stripped);
+	if (match === null) return null;
+	return {
+		major: Number(match[1]),
+		minor: Number(match[2]),
+		patch: Number(match[3])
+	};
+};
+const compareSemver = (a, b) => {
+	if (a.major !== b.major) return a.major - b.major;
+	if (a.minor !== b.minor) return a.minor - b.minor;
+	return a.patch - b.patch;
+};
+const satisfiesRange = (actual, min, prefix) => {
+	if (prefix === "^") return actual.major === min.major && compareSemver(actual, min) >= 0;
+	if (prefix === "~") {
+		if (actual.major !== min.major || actual.minor !== min.minor) return false;
+		return actual.patch >= min.patch;
+	}
+	return compareSemver(actual, min) >= 0;
+};
+const splitRange = (engine) => {
+	const trimmed = engine.trim();
+	const match = /^(>=|\^|~)(.+)$/.exec(trimmed);
+	if (match === null) return {
+		prefix: ">=",
+		rawMin: trimmed
+	};
+	return {
+		prefix: match[1],
+		rawMin: match[2] ?? ""
+	};
+};
+/**
+* Check whether a Bun runtime version satisfies a simple engines range.
+*
+* Supports `>=A.B.C`, `^A.B.C`, `~A.B.C`. Returns ok=true if `engine` is
+* undefined (no constraint). Pre-release suffixes on `bunVersion` are stripped
+* for the comparison.
+*
+* @param bunVersion - The current `Bun.version` string.
+* @param engine - The `engines.bun` field from package.json (or undefined).
+* @returns A {@link VersionCheck} with `ok: false` carrying a user-facing message.
+*/
+const checkBunVersion = (bunVersion, engine) => {
+	if (engine === void 0) return { ok: true };
+	const actual = parseSemver(bunVersion);
+	if (actual === null) return {
+		ok: false,
+		message: `Unable to parse Bun version: ${bunVersion}`
+	};
+	const { prefix, rawMin } = splitRange(engine);
+	const min = parseSemver(rawMin);
+	if (min === null) return {
+		ok: false,
+		message: `Unable to parse engine range: ${engine}`
+	};
+	if (satisfiesRange(actual, min, prefix)) return { ok: true };
+	return {
+		ok: false,
+		message: `Bun ${bunVersion} does not satisfy engines.bun "${engine}". Install Bun ${rawMin} or newer.`
+	};
+};
+
+//#endregion
+//#region src/bin/cli.ts
+/** @file runCli — pure dispatch over injected deps. Tested without spawning subprocesses. */
+/**
+* Top-level CLI dispatcher.
+*
+* Exit codes:
+*   0 - success
+*   1 - config / discovery error
+*   2 - build / runtime error
+*   3 - invalid arguments
+*   4 - unsupported runtime
+*
+* @param argv - Argv slice (already stripped of `node`/`bun` + script path).
+* @param deps - Injected dependencies.
+* @returns The exit code wrapper.
+*/
+const runCli = async (argv, deps) => {
+	const top = parseTopLevel(argv);
+	if (top.kind === "version") {
+		deps.stdout(deps.version);
+		return { code: 0 };
+	}
+	if (top.kind === "help") {
+		deps.stdout(formatBanner(deps.version));
+		deps.stdout(formatHelp());
+		return { code: 0 };
+	}
+	if (top.kind === "unknown-flag") {
+		deps.stderr(`Unknown flag: ${top.flag}`);
+		deps.stdout(formatHelp());
+		return { code: 3 };
+	}
+	const versionCheck = checkBunVersion(deps.bunVersion, deps.bunEngine);
+	if (!versionCheck.ok) {
+		deps.stderr(versionCheck.message);
+		return { code: 4 };
+	}
+	deps.stdout(formatBanner(deps.version));
+	switch (top.command) {
+		case "build": return deps.buildCommand(top.rest);
+		case "dev": return deps.devCommand(top.rest);
+		case "preview": return deps.previewCommand(top.rest);
+		default:
+			deps.stderr(`Unknown command: ${top.command}`);
+			deps.stdout(formatHelp());
+			return { code: 3 };
+	}
+};
+
+//#endregion
+//#region src/bin/commands/prepare.ts
+/**
+* Parse argv, branch on help/error, then load the app. Reduces command
+* complexity by hiding the four-way branch behind a single discriminant.
+*
+* @param options - Parser + loader + cwd.
+* @returns A {@link PreparedOutcome}.
+*/
+const prepareApp = async (options) => {
+	const parsed = options.parse(options.argv);
+	if (!parsed.ok) return {
+		kind: "bad-args",
+		message: parsed.message
+	};
+	if (parsed.value.help) return { kind: "help" };
+	const loaded = await options.loadApp({
+		cwd: options.cwd,
+		folder: parsed.value.folder
+	});
+	if (!loaded.ok) return {
+		kind: "load-failed",
+		message: loaded.message
+	};
+	return {
+		kind: "ready",
+		args: parsed.value,
+		app: loaded.value
+	};
+};
+/**
+* Time a build run and report it.
+*
+* @param app - The loaded CliApp.
+* @param stdout - Output channel.
+* @returns Exit code (0 ok, 2 build failure) and message already emitted.
+*/
+const runBuildOnce = async (app, stdout, stderr) => {
+	const start = performance.now();
+	try {
+		await app.build.run();
+	} catch (error) {
+		stderr(`Build failed: ${error.message}`);
+		return { code: 2 };
+	}
+	stdout(`Built in ${Math.round((performance.now() - start) / 100) / 10}s`);
+	return { code: 0 };
+};
+
+//#endregion
+//#region src/bin/commands/build.ts
+/** @file `moku build` command — load app, run app.build.run(), report timing. */
+/**
+* Run the build subcommand.
+*
+* @param argv - Argv after the `build` keyword.
+* @param deps - Injected IO / loader dependencies.
+* @returns Exit code: 0 ok, 1 config error, 2 build error, 3 arg error.
+*/
+const buildCommand = async (argv, deps) => {
+	const prepared = await prepareApp({
+		argv,
+		parse: parseBuild,
+		loadApp: deps.loadApp,
+		cwd: deps.cwd
+	});
+	if (prepared.kind === "help") {
+		deps.stdout(formatBuildHelp());
+		return { code: 0 };
+	}
+	if (prepared.kind === "bad-args") {
+		deps.stderr(prepared.message);
+		deps.stdout(formatBuildHelp());
+		return { code: 3 };
+	}
+	if (prepared.kind === "load-failed") {
+		deps.stderr(prepared.message);
+		return { code: 1 };
+	}
+	return runBuildOnce(prepared.app, deps.stdout, deps.stderr);
+};
+
+//#endregion
+//#region src/bin/commands/dev.ts
+/** @file `moku dev` command — watch + invalidate + rebuild + serve loop. */
+const makeRebuildHandler = (app, deps) => async (paths) => {
+	if (app.content !== void 0) app.content.invalidate(paths);
+	try {
+		await app.build.run();
+		deps.stdout(`[dev] Rebuilt (${paths.length} change${paths.length === 1 ? "" : "s"})`);
+	} catch (error) {
+		deps.stderr(`[dev] Rebuild failed: ${error.message}`);
+	}
+};
+const startDevServer = (app, deps, port) => {
+	const outdir = app.config?.build?.outdir ?? "dist";
+	const defaultLocale = app.config?.i18n?.defaultLocale ?? "en";
+	return deps.serve({
+		rootDir: resolve(deps.cwd, outdir),
+		port,
+		defaultLocale
+	});
+};
+/**
+* Run the dev subcommand.
+*
+* Builds once, then watches `contentDir` and on each batch invalidates
+* content paths BEFORE calling `app.build.run()` (hard rule from CLAUDE.md).
+*
+* @param argv - Argv after the `dev` keyword.
+* @param deps - Injected IO / loader / watch / serve dependencies.
+* @returns Exit code: 0 ok, 1 config error, 2 build error, 3 arg error.
+*/
+const devCommand = async (argv, deps) => {
+	const prepared = await prepareApp({
+		argv,
+		parse: parseDev,
+		loadApp: deps.loadApp,
+		cwd: deps.cwd
+	});
+	if (prepared.kind === "help") {
+		deps.stdout(formatDevHelp());
+		return { code: 0 };
+	}
+	if (prepared.kind === "bad-args") {
+		deps.stderr(prepared.message);
+		deps.stdout(formatDevHelp());
+		return { code: 3 };
+	}
+	if (prepared.kind === "load-failed") {
+		deps.stderr(prepared.message);
+		return { code: 1 };
+	}
+	try {
+		await prepared.app.build.run();
+	} catch (error) {
+		deps.stderr(`Initial build failed: ${error.message}`);
+		return { code: 2 };
+	}
+	const handle = startDevServer(prepared.app, deps, prepared.args.port);
+	deps.stdout(`[dev] Serving at http://localhost:${handle.port}`);
+	deps.watch({
+		rootDir: deps.cwd,
+		contentDir: resolve(deps.cwd, "content"),
+		onChange: makeRebuildHandler(prepared.app, deps)
+	});
+	return { code: 0 };
+};
+
+//#endregion
+//#region src/bin/commands/preview.ts
+/** @file `moku preview` command — build once, then serve the outdir. */
+const startPreviewServer = (app, cwd, port, serve) => {
+	const outdir = app.config?.build?.outdir ?? "dist";
+	const defaultLocale = app.config?.i18n?.defaultLocale ?? "en";
+	return serve({
+		rootDir: resolve(cwd, outdir),
+		port,
+		defaultLocale
+	});
+};
+/**
+* Run the preview subcommand.
+*
+* @param argv - Argv after the `preview` keyword.
+* @param deps - Injected IO / loader / serve dependencies.
+* @returns Exit code: 0 ok, 1 config error, 2 build error, 3 arg error.
+*/
+const previewCommand = async (argv, deps) => {
+	const prepared = await prepareApp({
+		argv,
+		parse: parsePreview,
+		loadApp: deps.loadApp,
+		cwd: deps.cwd
+	});
+	if (prepared.kind === "help") {
+		deps.stdout(formatPreviewHelp());
+		return { code: 0 };
+	}
+	if (prepared.kind === "bad-args") {
+		deps.stderr(prepared.message);
+		deps.stdout(formatPreviewHelp());
+		return { code: 3 };
+	}
+	if (prepared.kind === "load-failed") {
+		deps.stderr(prepared.message);
+		return { code: 1 };
+	}
+	const build = await runBuildOnce(prepared.app, deps.stdout, deps.stderr);
+	if (build.code !== 0) return build;
+	const handle = startPreviewServer(prepared.app, deps.cwd, prepared.args.port, deps.serve);
+	deps.stdout(`[preview] Serving at http://localhost:${handle.port}`);
+	return { code: 0 };
+};
+
+//#endregion
+//#region src/bin/load-app.ts
+/** @file Discovers and dynamically imports the consumer's main.ts entry. */
+/**
+* Dynamically import `{cwd}/{folder}/main.ts` and return its default export.
+*
+* Returns a structured result rather than throwing; the CLI maps errors to
+* exit codes.
+*
+* @param options - The cwd and folder to look in.
+* @returns A {@link LoadResult}.
+*/
+const loadApp = async (options) => {
+	const mainPath = resolve(options.cwd, options.folder, "main.ts");
+	if (!existsSync(mainPath)) return {
+		ok: false,
+		message: `main.ts not found at ${mainPath}. Run \`moku <command> <folder>\` with the correct path.`,
+		path: mainPath
+	};
+	try {
+		const mod = await import(mainPath);
+		if (mod.default === void 0) return {
+			ok: false,
+			message: `${mainPath} has no default export. Export your createApp() result as default.`,
+			path: mainPath
+		};
+		return {
+			ok: true,
+			value: mod.default,
+			path: mainPath
+		};
+	} catch (error) {
+		return {
+			ok: false,
+			message: `Failed to import ${mainPath}: ${error.message}`,
+			path: mainPath
+		};
+	}
+};
+
+//#endregion
+//#region src/bin/serve.ts
+/** @file Static file handler used by `moku preview` and `moku dev`. */
+const MIME_TYPES = new Map([
+	[".html", "text/html; charset=utf-8"],
+	[".css", "text/css; charset=utf-8"],
+	[".js", "application/javascript; charset=utf-8"],
+	[".mjs", "application/javascript; charset=utf-8"],
+	[".json", "application/json; charset=utf-8"],
+	[".svg", "image/svg+xml"],
+	[".png", "image/png"],
+	[".jpg", "image/jpeg"],
+	[".jpeg", "image/jpeg"],
+	[".gif", "image/gif"],
+	[".webp", "image/webp"],
+	[".ico", "image/x-icon"],
+	[".txt", "text/plain; charset=utf-8"],
+	[".xml", "application/xml; charset=utf-8"],
+	[".woff", "font/woff"],
+	[".woff2", "font/woff2"]
+]);
+const mimeFor = (path) => MIME_TYPES.get(extname(path).toLowerCase()) ?? "application/octet-stream";
+const isPathInside = (parent, child) => `${child}${sep}`.startsWith(`${parent}${sep}`);
+const resolveTarget = (rootDir, urlPath) => {
+	const target = resolve(rootDir, normalize(`./${decodeURIComponent(urlPath).replaceAll("\\", "/").replace(/\/+/g, "/")}`));
+	if (!isPathInside(rootDir, target) && target !== rootDir) return null;
+	return target;
+};
+const resolveFilePath = (target, urlPath) => {
+	const candidate = urlPath.endsWith("/") ? resolve(target, "index.html") : target;
+	if (!existsSync(candidate)) return null;
+	if (!statSync(candidate).isDirectory()) return candidate;
+	const indexed = resolve(candidate, "index.html");
+	return existsSync(indexed) ? indexed : null;
+};
+const fileResponse = (path) => new Response(readFileSync(path), { headers: { "content-type": mimeFor(path) } });
+/**
+* Build a fetch-style handler that serves files from `rootDir`.
+*
+* Behavior:
+* - Bare `/` redirects (307) to `/{defaultLocale}/`.
+* - Paths ending in `/` look for `index.html`.
+* - Path traversal attempts return 403.
+* - Missing files return 404.
+*
+* @param options - The root directory and default locale.
+* @returns A `(request: Request) => Promise<Response>` handler.
+*/
+const createStaticHandler = (options) => {
+	const root = resolve(options.rootDir);
+	return async (request) => {
+		const url = new URL(request.url);
+		if (url.pathname === "/") return new Response(null, {
+			status: 307,
+			headers: { location: `/${options.defaultLocale}/` }
+		});
+		const target = resolveTarget(root, url.pathname);
+		if (target === null) return new Response("Forbidden", { status: 403 });
+		const filePath = resolveFilePath(target, url.pathname);
+		if (filePath === null) return new Response("Not Found", { status: 404 });
+		return fileResponse(filePath);
+	};
+};
+
+//#endregion
+//#region src/bin/watch.ts
+/**
+* Create a trailing-edge debounced change batcher.
+*
+* Each `push(path)` (re)starts the debounce timer. When the timer fires the
+* collected unique paths are passed to `onFlush` and a new batch begins.
+* `flush()` drains immediately; `dispose()` cancels any pending flush without
+* invoking the callback.
+*
+* @param options - Debounce window + flush callback.
+* @returns The {@link ChangeBatcher} handle.
+*/
+const createChangeBatcher = (options) => {
+	let pending = /* @__PURE__ */ new Set();
+	let timer = null;
+	const clearTimer = () => {
+		if (timer !== null) {
+			clearTimeout(timer);
+			timer = null;
+		}
+	};
+	const drain = () => {
+		clearTimer();
+		if (pending.size === 0) return;
+		const batch = [...pending];
+		pending = /* @__PURE__ */ new Set();
+		options.onFlush(batch);
+	};
+	return {
+		push: (path) => {
+			pending.add(path);
+			clearTimer();
+			timer = setTimeout(drain, options.debounceMs);
+		},
+		flush: drain,
+		dispose: () => {
+			clearTimer();
+			pending = /* @__PURE__ */ new Set();
+		}
+	};
+};
+
+//#endregion
+//#region src/bin/moku.ts
+/** @file moku CLI entry — wires runtime IO to runCli. NOT a plugin. */
+const findPackageJson = () => {
+	const candidates = [
+		resolve(import.meta.dir, "..", "..", "package.json"),
+		resolve(import.meta.dir, "..", "package.json"),
+		resolve(process.cwd(), "package.json")
+	];
+	for (const candidate of candidates) if (existsSync(candidate)) return JSON.parse(readFileSync(candidate, "utf8"));
+	return {};
+};
+const pkg = findPackageJson();
+const stdout = (line) => {
+	process.stdout.write(`${line}\n`);
+};
+const stderr = (line) => {
+	process.stderr.write(`${line}\n`);
+};
+const serveStatic = (options) => {
+	const handler = createStaticHandler({
+		rootDir: options.rootDir,
+		defaultLocale: options.defaultLocale
+	});
+	const server = Bun.serve({
+		port: options.port,
+		fetch: handler
+	});
+	return {
+		port: server.port ?? options.port,
+		stop: () => server.stop()
+	};
+};
+const startWatcher = (options) => {
+	const batcher = createChangeBatcher({
+		debounceMs: 50,
+		onFlush: (paths) => options.onChange(paths)
+	});
+	if (!existsSync(options.contentDir)) return { stop: () => batcher.dispose() };
+	const watcher = watch(options.contentDir, { recursive: true }, (_event, filename) => {
+		if (filename !== null) batcher.push(filename.toString());
+	});
+	return { stop: () => {
+		watcher.close();
+		batcher.dispose();
+	} };
+};
+const main = async () => {
+	const result = await runCli(process.argv.slice(2), {
+		cwd: process.cwd(),
+		version: pkg.version ?? "0.0.0",
+		bunVersion: Bun.version,
+		bunEngine: pkg.engines?.bun,
+		stdout,
+		stderr,
+		buildCommand: (argv) => buildCommand(argv, {
+			cwd: process.cwd(),
+			stdout,
+			stderr,
+			loadApp
+		}),
+		devCommand: (argv) => devCommand(argv, {
+			cwd: process.cwd(),
+			stdout,
+			stderr,
+			loadApp,
+			watch: startWatcher,
+			serve: serveStatic
+		}),
+		previewCommand: (argv) => previewCommand(argv, {
+			cwd: process.cwd(),
+			stdout,
+			stderr,
+			loadApp,
+			serve: serveStatic
+		})
+	});
+	process.exit(result.code);
+};
+main();
+
+//#endregion
+export {  };