unrun 0.1.0 → 0.2.1

package/README.md

@@ -1,55 +1,58 @@
 # unrun
 
-[![NPM version](https://img.shields.io/npm/v/unrun.svg?style=flat)](https://npmjs.com/package/unrun) [![NPM downloads](https://img.shields.io/npm/dm/unrun.svg?style=flat)](https://npmjs.com/package/unrun) [![Build Status](https://img.shields.io/circleci/project/egoist/unrun/master.svg?style=flat)](https://circleci.com/gh/egoist/unrun) [![donate](https://img.shields.io/badge/$-donate-ff69b4.svg?maxAge=2592000&style=flat)](https://github.com/egoist/donate)
+[![npm version][npm-version-src]][npm-version-href]
+[![npm downloads][npm-downloads-src]][npm-downloads-href]
+[![Unit Test][unit-test-src]][unit-test-href]
 
-## Features
+unrun is a tool that enables running any module at runtime (TypeScript, ESM, CJS, JSX, etc.) by bundling it with [Rolldown](https://rolldown.rs/).
 
-- Show description for each npm script
-- Use `yarn run` instead of `npm run` by default
+It is highly inspired by tools like :
+
+- [jiti](https://github.com/unjs/jiti)
+- [bundle-require](https://github.com/egoist/bundle-require)
+- [tsx](https://tsx.is/)
 
 ## Install
 
 ```bash
-$ yarn global add unrun
+npm i unrun
 ```
 
 ## Usage
 
-With following contents in `package.json`:
-
-```json
-{
-  "scripts": {
-    "api": "node server.js",
-    "stats": "webpack-bundle-analyzer stats.json",
-    "size": "tree ./dist -L 1  -h"
-  },
-  "unrun": {
-    "api": "Start the API server",
-    "stats": "Represents bundle content as convenient interactive zoomable treemap",
-    "size": "Show bundle size"
-  }
-}
-```
+### Programmatic API
 
-```bash
-$ unrun
+- Async
+
+```ts
+import { unrun } from 'unrun'
+
+const { module } = await unrun({
+  path: './path/to/file.ts', // Path to the module to load
+})
 ```
 
-<img src="https://ooo.0o0.ooo/2017/03/18/58cd3c92b6c31.png" width="600" />
+- Sync
 
-## Contributing
+```ts
+import { unrunSync } from 'unrun'
 
-1. Fork it!
-2. Create your feature branch: `git checkout -b my-new-feature`
-3. Commit your changes: `git commit -am 'Add some feature'`
-4. Push to the branch: `git push origin my-new-feature`
-5. Submit a pull request :D
+const { module } = unrunSync({
+  path: './path/to/file.ts', // Path to the module to load
+})
+```
 
+### CLI
 
-## Author
+```bash
+npx unrun ./path/to/file.ts
+```
 
-**unrun** © [egoist](https://github.com/egoist), Released under the [MIT](./LICENSE) License.<br>
-Authored and maintained by egoist with help from contributors ([list](https://github.com/egoist/unrun/contributors)).
+<!-- Badges -->
 
-> [egoistian.com](https://egoistian.com) · GitHub [@egoist](https://github.com/egoist) · Twitter [@rem_rin_rin](https://twitter.com/rem_rin_rin)
+[npm-version-src]: https://img.shields.io/npm/v/unrun.svg
+[npm-version-href]: https://npmjs.com/package/unrun
+[npm-downloads-src]: https://img.shields.io/npm/dm/unrun
+[npm-downloads-href]: https://www.npmcharts.com/compare/unrun?interval=30
+[unit-test-src]: https://github.com/gugustinette/unrun/actions/workflows/unit-test.yml/badge.svg
+[unit-test-href]: https://github.com/gugustinette/unrun/actions/workflows/unit-test.yml

package/dist/cli.d.ts

@@ -0,0 +1 @@
+export { };

package/dist/cli.js

@@ -0,0 +1,103 @@
+import process from "node:process";
+
+//#region src/cli.ts
+function parseCLIArguments(argv) {
+	let debug = false;
+	let preset;
+	let filePath;
+	const beforeArgs = [];
+	const afterArgs = [];
+	let expectFilePathAfterDelimiter = false;
+	for (let index = 0; index < argv.length; index += 1) {
+		const argument = argv[index];
+		if (filePath !== void 0) {
+			if (argument === "--") {
+				afterArgs.push(...argv.slice(index + 1));
+				break;
+			}
+			afterArgs.push(argument);
+			continue;
+		}
+		if (expectFilePathAfterDelimiter) {
+			filePath = argument;
+			expectFilePathAfterDelimiter = false;
+			continue;
+		}
+		if (argument === "--") {
+			expectFilePathAfterDelimiter = true;
+			beforeArgs.push(argument);
+			continue;
+		}
+		if (argument === "--debug") {
+			debug = true;
+			beforeArgs.push(argument);
+			continue;
+		}
+		if (argument === "--no-debug") {
+			debug = false;
+			beforeArgs.push(argument);
+			continue;
+		}
+		if (argument.startsWith("--preset=")) {
+			preset = argument.slice(9);
+			beforeArgs.push(argument);
+			continue;
+		}
+		if (argument === "--preset") {
+			const presetValue = argv[index + 1];
+			if (!presetValue || presetValue.startsWith("-")) throw new Error("[unrun] Missing preset value after --preset");
+			preset = presetValue;
+			beforeArgs.push(argument, presetValue);
+			index += 1;
+			continue;
+		}
+		if (argument.startsWith("-")) {
+			beforeArgs.push(argument);
+			continue;
+		}
+		filePath = argument;
+	}
+	return {
+		debug,
+		preset,
+		filePath,
+		beforeArgs,
+		afterArgs
+	};
+}
+async function runCLI() {
+	let parsedArguments;
+	try {
+		parsedArguments = parseCLIArguments(process.argv.slice(2));
+	} catch (error) {
+		console.error(error.message);
+		process.exit(1);
+	}
+	if (!parsedArguments.filePath) {
+		console.error("[unrun] No input files provided");
+		process.exit(1);
+	}
+	process.argv = [
+		process.argv[0],
+		parsedArguments.filePath,
+		...parsedArguments.afterArgs
+	];
+	try {
+		const { unrunCli } = await import("./index.js");
+		await unrunCli({
+			path: parsedArguments.filePath,
+			debug: parsedArguments.debug,
+			preset: parsedArguments.preset
+		}, parsedArguments.afterArgs);
+	} catch (error) {
+		console.error(error.message);
+		process.exit(1);
+	}
+}
+runCLI().catch((error) => {
+	console.error(error.message);
+	process.exit(1);
+});
+
+//#endregion
+export {  };

package/dist/index.d.ts

@@ -0,0 +1,75 @@
+import { InputOptions, OutputOptions } from "rolldown";
+
+//#region src/options.d.ts
+interface Options {
+  /**
+  * The path to the file to be imported. Supports filesystem paths, file URLs or URL objects.
+  * @default 'index.ts'
+  */
+  path?: string | URL;
+  /**
+  * Debug mode.
+  * Wether or not to keep temporary files to help with debugging.
+  * Temporary files are stored in `node_modules/.cache/unrun/` if possible,
+  * otherwise in the OS temporary directory.
+  * @default false
+  */
+  debug?: boolean;
+  /**
+  * The preset to use for bundling and output format.
+  * @default 'none'
+  */
+  preset?: "none" | "jiti" | "bundle-require";
+  /**
+  * Additional rolldown input options. These options will be merged with the
+  * defaults provided by unrun, with these options always taking precedence.
+  */
+  inputOptions?: InputOptions;
+  /**
+  * Additional rolldown output options. These options will be merged with the
+  * defaults provided by unrun, with these options always taking precedence.
+  */
+  outputOptions?: OutputOptions;
+}
+//#endregion
+//#region src/types.d.ts
+interface Result {
+  /**
+  * The module that was loaded.
+  */
+  module: any;
+}
+interface CliResult {
+  /**
+  * The exit code of the CLI execution.
+  */
+  exitCode: number;
+}
+//#endregion
+//#region src/index.d.ts
+/**
+* Loads a module with JIT transpilation based on the provided options.
+*
+* @param options - The options for loading the module.
+* @returns A promise that resolves to the loaded module.
+*/
+declare function unrun(options: Options): Promise<Result>;
+/**
+* Loads a module with JIT transpilation based on the provided options.
+* This function runs synchronously using a worker thread.
+*
+* @param options - The options for loading the module.
+* @returns The loaded module.
+*/
+declare function unrunSync(options: Options): Result;
+/**
+* Runs a given module with JIT transpilation based on the provided options.
+* This function does not return the module, as it simply executes it.
+* Corresponds to the CLI behavior.
+*
+* @param options - The options for running the module.
+* @param args - Additional command-line arguments to pass to the module.
+*/
+declare function unrunCli(options: Options, args?: string[]): Promise<CliResult>;
+//#endregion
+export { type CliResult, type Options, type Result, unrun, unrunCli, unrunSync };

package/dist/index.js

@@ -0,0 +1,3 @@
+import { n as unrunCli, r as unrunSync, t as unrun } from "./src-CRcGnzTd.js";
+
+export { unrun, unrunCli, unrunSync };

package/dist/src-CRcGnzTd.js

@@ -0,0 +1,583 @@
+import { createRequire } from "node:module";
+import process from "node:process";
+import { createSyncFn } from "synckit";
+import path from "node:path";
+import fs, { existsSync } from "node:fs";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { rolldown } from "rolldown";
+import { Buffer as Buffer$1 } from "node:buffer";
+import { spawn } from "node:child_process";
+import crypto from "node:crypto";
+import { tmpdir } from "node:os";
+
+//#region rolldown:runtime
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+//#endregion
+//#region src/features/preset.ts
+/**
+* Applies preset-specific handling to the loaded module.
+*/
+function preset(options, module) {
+	if (options.preset === "bundle-require") return module;
+	if (options.preset === "jiti") {
+		const ext = path.extname(options.path);
+		if (module && typeof module === "object" && module[Symbol.toStringTag] === "Module" && Object.keys(module).length === 0) return ext === ".mjs" ? module : {};
+	}
+	if (module && typeof module === "object" && "default" in module) return module.default;
+	return module;
+}
+
+//#endregion
+//#region src/utils/normalize-path.ts
+/**
+* Normalize a path-like input to a string path.
+* @param pathLike The path-like input (string or URL).
+* @returns The normalized string path.
+*/
+function normalizePath(pathLike) {
+	if (!pathLike) return "index.ts";
+	if (pathLike instanceof URL) {
+		if (pathLike.protocol === "file:") return fileURLToPath(pathLike);
+		return pathLike.href;
+	}
+	if (typeof pathLike === "string") {
+		if (!pathLike.startsWith("file:")) return pathLike;
+		try {
+			return fileURLToPath(pathLike);
+		} catch {
+			try {
+				return fileURLToPath(new URL(pathLike));
+			} catch {
+				return pathLike;
+			}
+		}
+	}
+	return String(pathLike);
+}
+
+//#endregion
+//#region src/options.ts
+function resolveOptions(options = {}) {
+	const resolvedOptions = {
+		path: path.resolve(process.cwd(), normalizePath(options.path)),
+		debug: options.debug || false,
+		preset: options.preset || "none",
+		inputOptions: options.inputOptions,
+		outputOptions: options.outputOptions
+	};
+	if (!fs.existsSync(resolvedOptions.path)) throw new Error(`[unrun] File not found: ${resolvedOptions.path}`);
+	if (!new Set([
+		"none",
+		"jiti",
+		"bundle-require"
+	]).has(resolvedOptions.preset)) throw new Error(`[unrun] Invalid preset "${resolvedOptions.preset}" (expected: none | jiti | bundle-require)`);
+	return resolvedOptions;
+}
+
+//#endregion
+//#region src/plugins/console-output-customizer.ts
+/**
+* Attach a util.inspect customizer to namespace-like module objects produced by rolldown helpers
+* so console.log prints concrete values instead of [Getter], while preserving live bindings.
+*
+* Cleaner strategy: inject a tiny helper at the top of the chunk and minimally augment
+* rolldown helpers (__export and __copyProps) right inside their definitions, before use.
+*/
+function createConsoleOutputCustomizer() {
+	return {
+		name: "unrun-console-output-customizer",
+		generateBundle: { handler(_, bundle$1) {
+			for (const chunk of Object.values(bundle$1)) {
+				if (chunk.type !== "chunk") continue;
+				if (!/__unrun__setInspect\b/.test(chunk.code)) {
+					const helper = [
+						"(function(){",
+						"  function __unrun__fmt(names, getter, np){",
+						"    var onlyDefault = names.length === 1 && names[0] === \"default\";",
+						"    var o = np ? Object.create(null) : {};",
+						"    for (var i = 0; i < names.length; i++) {",
+						"      var n = names[i];",
+						"      try { o[n] = getter(n) } catch {}",
+						"    }",
+						"    if (onlyDefault) {",
+						"      try {",
+						"        var s = JSON.stringify(o.default);",
+						"        if (s !== undefined) {",
+						"          s = s.replace(/\"([^\"]+)\":/g, \"$1: \").replace(/,/g, \", \").replace(/{/g, \"{ \").replace(/}/g, \" }\");",
+						"          return \"[Module: null prototype] { default: \" + s + \" }\";",
+						"        }",
+						"      } catch {}",
+						"      return \"[Module: null prototype] { default: \" + String(o.default) + \" }\";",
+						"    }",
+						"    return o;",
+						"  }",
+						"  function __unrun__setInspect(obj, names, getter, np){",
+						"    try {",
+						"      var __insp = Symbol.for('nodejs.util.inspect.custom')",
+						"      Object.defineProperty(obj, __insp, {",
+						"        value: function(){ return __unrun__fmt(names, getter, np) },",
+						"        enumerable: false, configurable: true",
+						"      })",
+						"    } catch {}",
+						"    return obj;",
+						"  }",
+						"  try { Object.defineProperty(globalThis, \"__unrun__setInspect\", { value: __unrun__setInspect, enumerable: false }) } catch {}",
+						"})();"
+					].join("\n");
+					if (chunk.code.startsWith("#!")) {
+						const nl = chunk.code.indexOf("\n");
+						if (nl !== -1) chunk.code = `${chunk.code.slice(0, nl + 1)}${helper}\n${chunk.code.slice(nl + 1)}`;
+						else chunk.code = `${helper}\n${chunk.code}`;
+					} else chunk.code = `${helper}\n${chunk.code}`;
+				}
+				chunk.code = chunk.code.replace(/var\s+__export\s*=\s*\(all\)\s*=>\s*\{([\s\S]*?)return\s+target;\s*\}/, (_m, body) => {
+					return `var __export = (all) => {\n${[
+						body,
+						"  try {",
+						"    var __names = Object.keys(all).filter(function(n){ return n !== \"__esModule\" })",
+						"    __unrun__setInspect(target, __names, function(n){ return all[n]() }, false)",
+						"  } catch {}",
+						"  return target;"
+					].join("\n")}\n}`;
+				});
+				chunk.code = chunk.code.replace(/var\s+__copyProps\s*=\s*\(to,\s*from,\s*except,\s*desc\)\s*=>\s*\{([\s\S]*?)return\s+to;\s*\};/, (_m, body) => {
+					return `var __copyProps = (to, from, except, desc) => {\n${[
+						body,
+						"  try {",
+						"    var __names = Object.keys(to).filter(function(n){ return n !== \"__esModule\" })",
+						"    __unrun__setInspect(to, __names, function(n){ return to[n] }, true)",
+						"  } catch {}",
+						"  return to;"
+					].join("\n")}\n};`;
+				});
+			}
+		} }
+	};
+}
+
+//#endregion
+//#region src/plugins/json-loader.ts
+/**
+* Minimal JSON loader to mimic jiti/Node behavior expected by tests:
+* - Default export is the parsed JSON object
+* - Also add a self-reference `default` property on the object (so obj.default === obj)
+* - Provide named exports for top-level properties
+*/
+function createJsonLoader() {
+	return {
+		name: "unrun-json-loader",
+		resolveId: { handler(source, importer) {
+			if (!source.endsWith(".json")) return null;
+			const basedir = importer ? path.dirname(importer) : process.cwd();
+			const resolved = path.resolve(basedir, source);
+			let isRequire = false;
+			try {
+				if (importer) {
+					const src = fs.readFileSync(importer, "utf8");
+					const escaped = source.replaceAll(/[.*+?^${}()|[\]\\]/g, (m) => `\\${m}`);
+					const pattern = String.raw`\brequire\s*\(\s*['"]${escaped}['"]\s*\)`;
+					isRequire = new RegExp(pattern).test(src);
+				}
+			} catch {}
+			return { id: `${resolved}?unrun-json.${isRequire ? "cjs" : "mjs"}` };
+		} },
+		load: {
+			filter: { id: /\?unrun-json\.(?:mjs|cjs)$/ },
+			handler(id) {
+				try {
+					const realId = id.replace(/\?unrun-json\.(?:mjs|cjs)$/, "");
+					const src = fs.readFileSync(realId, "utf8");
+					const data = JSON.parse(src);
+					const jsonLiteral = JSON.stringify(data);
+					if (id.endsWith("?unrun-json.cjs")) return { code: `const __data = ${jsonLiteral}\ntry { Object.defineProperty(__data, 'default', { value: __data, enumerable: false, configurable: true }) } catch {}\nmodule.exports = __data\n` };
+					const named = Object.keys(data).filter((k) => /^[$A-Z_]\w*$/i.test(k)).map((k) => `export const ${k} = __data[${JSON.stringify(k)}]`).join("\n");
+					return { code: [
+						`const __data = ${jsonLiteral}`,
+						`try { Object.defineProperty(__data, 'default', { value: __data, enumerable: false, configurable: true }) } catch {}`,
+						named,
+						`export default __data`
+					].filter(Boolean).join("\n") };
+				} catch {
+					return null;
+				}
+			}
+		}
+	};
+}
+
+//#endregion
+//#region src/plugins/make-cjs-wrapper-async-friendly.ts
+/**
+* Transforms code strings containing CommonJS wrappers to be async-friendly.
+*
+* Rolldown may wrap CommonJS modules in a `__commonJS` function that uses
+* arrow functions. If the wrapped code contains top-level `await`, this can lead
+* to syntax errors since the callback function won't be marked as `async`.
+* This function scans for such patterns and modifies the arrow functions to
+* be `async` if they contain `await` expressions.
+*/
+function createMakeCjsWrapperAsyncFriendlyPlugin() {
+	return {
+		name: "unrun-make-cjs-wrapper-async-friendly",
+		generateBundle: { handler(_outputOptions, bundle$1) {
+			for (const chunk of Object.values(bundle$1)) {
+				if (chunk.type !== "chunk") continue;
+				let code = chunk.code;
+				const marker = "__commonJS({";
+				if (!code.includes(marker)) return;
+				let pos = 0;
+				const arrowToken = "(() => {";
+				const asyncArrowToken = "(async () => {";
+				while (true) {
+					const markerIdx = code.indexOf(marker, pos);
+					if (markerIdx === -1) break;
+					const fnStart = code.indexOf(arrowToken, markerIdx);
+					if (fnStart === -1) {
+						pos = markerIdx + 12;
+						continue;
+					}
+					const bodyStart = fnStart + 8;
+					let i = bodyStart;
+					let depth = 1;
+					while (i < code.length && depth > 0) {
+						const ch = code[i++];
+						if (ch === "{") depth++;
+						else if (ch === "}") depth--;
+					}
+					if (depth !== 0) break;
+					const bodyEnd = i - 1;
+					const body = code.slice(bodyStart, bodyEnd);
+					if (/\bawait\b/.test(body) && code.slice(fnStart, fnStart + 14) !== asyncArrowToken) {
+						code = `${code.slice(0, fnStart + 1)}async ${code.slice(fnStart + 1)}`;
+						pos = fnStart + 1 + 6;
+						continue;
+					}
+					pos = bodyEnd;
+				}
+				if (code !== chunk.code) chunk.code = code;
+			}
+		} }
+	};
+}
+
+//#endregion
+//#region src/plugins/require-resolve-fix.ts
+/**
+* Fix require.resolve calls to use the correct base path.
+* Replace __require.resolve("./relative") with proper resolution from original file location.
+*/
+function createRequireResolveFix(options) {
+	return {
+		name: "unrun-require-resolve-fix",
+		generateBundle: { handler(_, bundle$1) {
+			for (const chunk of Object.values(bundle$1)) if (chunk.type === "chunk") chunk.code = chunk.code.replaceAll(/__require\.resolve\(["']([^"']+)["']\)/g, (match, id) => {
+				if (id.startsWith("./") || id.startsWith("../")) try {
+					const baseDir = path.dirname(options.path);
+					for (const ext of [
+						"",
+						".ts",
+						".js",
+						".mts",
+						".mjs",
+						".cts",
+						".cjs"
+					]) {
+						const testPath = path.resolve(baseDir, id + ext);
+						if (fs.existsSync(testPath)) return JSON.stringify(testPath);
+					}
+					const resolvedPath = path.resolve(baseDir, id);
+					return JSON.stringify(resolvedPath);
+				} catch {
+					return match;
+				}
+				return match;
+			});
+		} }
+	};
+}
+
+//#endregion
+//#region src/plugins/require-typeof-fix.ts
+/**
+* Ensure typeof require in ESM stays undefined to match jiti behavior.
+* Replaces typeof __require with typeof require to maintain compatibility.
+*/
+function createRequireTypeofFix() {
+	return {
+		name: "unrun-require-typeof-fix",
+		generateBundle: { handler(_, bundle$1) {
+			for (const chunk of Object.values(bundle$1)) if (chunk.type === "chunk") chunk.code = chunk.code.replaceAll(/\btypeof\s+__require\b/g, "typeof require");
+		} }
+	};
+}
+
+//#endregion
+//#region src/plugins/source-context-shims.ts
+/**
+* A rolldown plugin that injects source context shims:
+* - Replaces import.meta.resolve calls with resolved file URLs
+* - Injects per-module __filename/__dirname
+* - Replaces import.meta.url with the source file URL
+*/
+function createSourceContextShimsPlugin() {
+	return {
+		name: "unrun-source-context-shims",
+		load: {
+			filter: { id: /\.(?:m?[jt]s|c?tsx?)(?:$|\?)/ },
+			handler(id) {
+				let code;
+				try {
+					code = fs.readFileSync(id, "utf8");
+				} catch {
+					return null;
+				}
+				let __MODIFIED_CODE__ = false;
+				if (code.includes("import.meta.resolve")) {
+					const replaced = code.replaceAll(/import\.meta\.resolve!?\s*\(\s*(["'])([^"']+)\1\s*\)/g, (_m, _q, spec) => {
+						const url = pathToFileURL(path.resolve(path.dirname(id), spec)).href;
+						return JSON.stringify(url);
+					});
+					if (replaced !== code) {
+						code = replaced;
+						__MODIFIED_CODE__ = true;
+					}
+				}
+				if (/__filename|__dirname|import\s*\.\s*meta\s*\.\s*url/.test(code)) {
+					const file = id;
+					const dir = path.dirname(id);
+					const url = pathToFileURL(id).href;
+					const prologue = `const __filename = ${JSON.stringify(file)}\nconst __dirname = ${JSON.stringify(dir)}\n`;
+					const protectedStrings = [];
+					let protectedCode = code.replaceAll(/(["'])[^"']*import\s*\.\s*meta\s*\.\s*url[^"']*\1\s*:/g, (match) => {
+						const placeholder = `__PROTECTED_STRING_${protectedStrings.length}__`;
+						protectedStrings.push(match);
+						return placeholder;
+					});
+					protectedCode = protectedCode.replaceAll(/\bimport\s*\.\s*meta\s*\.\s*url\b/g, JSON.stringify(url));
+					for (const [i, protectedString] of protectedStrings.entries()) protectedCode = protectedCode.replace(`__PROTECTED_STRING_${i}__`, protectedString);
+					code = prologue + protectedCode;
+					__MODIFIED_CODE__ = true;
+				}
+				return __MODIFIED_CODE__ ? { code } : null;
+			}
+		}
+	};
+}
+
+//#endregion
+//#region src/utils/bundle.ts
+async function bundle(options) {
+	const resolvedTsconfigPath = path.resolve(process.cwd(), "tsconfig.json");
+	const tsconfig = existsSync(resolvedTsconfigPath) ? resolvedTsconfigPath : void 0;
+	const inputOptions = {
+		input: options.path,
+		platform: "node",
+		external: (id) => !id.startsWith(".") && !id.startsWith("/") && !id.startsWith("#"),
+		plugins: [
+			createMakeCjsWrapperAsyncFriendlyPlugin(),
+			createRequireResolveFix(options),
+			createSourceContextShimsPlugin(),
+			...options.preset === "jiti" ? [
+				createConsoleOutputCustomizer(),
+				createJsonLoader(),
+				createRequireTypeofFix()
+			] : []
+		],
+		transform: { define: {
+			__dirname: JSON.stringify(path.dirname(options.path)),
+			__filename: JSON.stringify(options.path),
+			"import.meta.url": JSON.stringify(pathToFileURL(options.path).href),
+			"import.meta.filename": JSON.stringify(options.path),
+			"import.meta.dirname": JSON.stringify(path.dirname(options.path)),
+			"import.meta.env": "process.env"
+		} },
+		...options.inputOptions
+	};
+	if (tsconfig) inputOptions.tsconfig = tsconfig;
+	const bundle$1 = await rolldown(inputOptions);
+	const outputOptions = {
+		format: "esm",
+		inlineDynamicImports: true,
+		keepNames: true,
+		...options.outputOptions
+	};
+	const rolldownOutput = await bundle$1.generate(outputOptions);
+	if (!rolldownOutput.output[0]) throw new Error("[unrun] No output chunk found");
+	return rolldownOutput.output[0];
+}
+
+//#endregion
+//#region src/utils/module/clean-module.ts
+/**
+* Clean the module file at the given URL.
+* Deletes the file if it exists.
+* @param moduleUrl - The URL of the module file to be cleaned.
+*/
+function cleanModule(moduleUrl) {
+	try {
+		if (moduleUrl.startsWith("file://")) {
+			const filePath = new URL(moduleUrl);
+			fs.unlinkSync(filePath);
+		}
+	} catch (error) {
+		if (error.code !== "ENOENT") throw error;
+	}
+}
+
+//#endregion
+//#region src/utils/module/exec-module.ts
+/**
+* Execute the module at the given URL, in a separate Node.js process.
+* @param moduleUrl - The URL of the module to execute.
+* @param args - Additional command-line arguments to pass to the Node.js process.
+* @returns A promise that resolves when the module execution is complete.
+*/
+function execModule(moduleUrl, args = []) {
+	return new Promise((resolve, reject) => {
+		const nodePath = process.execPath;
+		const spawnArgs = [];
+		if (moduleUrl.startsWith("data:")) {
+			const commaIndex = moduleUrl.indexOf(",");
+			if (commaIndex === -1) {
+				reject(/* @__PURE__ */ new Error("[unrun]: Invalid data URL for module execution"));
+				return;
+			}
+			const metadata = moduleUrl.slice(5, commaIndex);
+			const payload = moduleUrl.slice(commaIndex + 1);
+			const code = metadata.endsWith(";base64") ? Buffer$1.from(payload, "base64").toString("utf8") : decodeURIComponent(payload);
+			spawnArgs.push("--input-type=module", "--eval", code);
+		} else {
+			let modulePath = moduleUrl;
+			if (moduleUrl.startsWith("file://")) try {
+				modulePath = fileURLToPath(moduleUrl);
+			} catch (error) {
+				reject(/* @__PURE__ */ new Error(`[unrun]: Failed to resolve module URL ${moduleUrl}: ${error.message}`));
+				return;
+			}
+			spawnArgs.push(modulePath);
+		}
+		const childProcess = spawn(nodePath, [...spawnArgs, ...args], { stdio: [
+			"inherit",
+			"inherit",
+			"inherit"
+		] });
+		childProcess.on("close", (exitCode) => {
+			resolve({ exitCode: exitCode ?? 0 });
+		});
+		childProcess.on("error", (error) => {
+			reject(/* @__PURE__ */ new Error(`[unrun]: Failed to start child process: ${error.message}`));
+		});
+	});
+}
+
+//#endregion
+//#region src/utils/module/write-module.ts
+function sanitize(name) {
+	return name.replaceAll(/[^\w.-]/g, "_");
+}
+/**
+* Writes a module to the filesystem.
+* @param code - The JavaScript code to be written as a module.
+* @param options - Resolved options.
+* @returns The file URL of the written module.
+*/
+function writeModule(code, options) {
+	const filenameHint = path.basename(options.path);
+	let moduleUrl = "";
+	try {
+		const randomKey = crypto.randomBytes(16).toString("hex");
+		const fname = `${filenameHint ? `${sanitize(filenameHint)}.` : ""}${randomKey}.mjs`;
+		const projectNodeModules = path.join(process.cwd(), "node_modules");
+		const outDir = path.join(projectNodeModules, ".unrun");
+		const outFile = path.join(outDir, fname);
+		if (!fs.existsSync(outFile)) try {
+			fs.mkdirSync(outDir, { recursive: true });
+			fs.writeFileSync(outFile, code, "utf8");
+		} catch {
+			const fallbackDir = path.join(tmpdir(), "unrun-cache");
+			const fallbackFile = path.join(fallbackDir, fname);
+			fs.mkdirSync(fallbackDir, { recursive: true });
+			fs.writeFileSync(fallbackFile, code, "utf8");
+			moduleUrl = pathToFileURL(fallbackFile).href;
+		}
+		moduleUrl = moduleUrl || pathToFileURL(outFile).href;
+	} catch {
+		moduleUrl = `data:text/javascript;base64,${Buffer$1.from(code).toString("base64")}`;
+	}
+	return moduleUrl;
+}
+
+//#endregion
+//#region src/utils/module/load-module.ts
+/**
+* Import a JS module from code string.
+* Write ESM code to a temp file (prefer project-local node_modules/.unrun) and import it.
+* @param code - The JavaScript code to be imported as a module.
+* @param options - Resolved options.
+* @returns The imported module.
+*/
+async function loadModule(code, options) {
+	const moduleUrl = writeModule(code, options);
+	let _module;
+	try {
+		_module = await import(moduleUrl);
+	} finally {
+		cleanModule(moduleUrl);
+	}
+	return _module;
+}
+
+//#endregion
+//#region src/index.ts
+/**
+* Loads a module with JIT transpilation based on the provided options.
+*
+* @param options - The options for loading the module.
+* @returns A promise that resolves to the loaded module.
+*/
+async function unrun(options) {
+	const resolvedOptions = resolveOptions(options);
+	const outputChunk = await bundle(resolvedOptions);
+	let module;
+	try {
+		module = await loadModule(outputChunk.code, resolvedOptions);
+	} catch (error) {
+		throw new Error(`[unrun] Import failed (code length: ${outputChunk.code.length}): ${error.message}`);
+	}
+	return { module: preset(resolvedOptions, module) };
+}
+/**
+* Loads a module with JIT transpilation based on the provided options.
+* This function runs synchronously using a worker thread.
+*
+* @param options - The options for loading the module.
+* @returns The loaded module.
+*/
+function unrunSync(options) {
+	return createSyncFn(__require.resolve("./sync/worker"), { tsRunner: "node" })(options);
+}
+/**
+* Runs a given module with JIT transpilation based on the provided options.
+* This function does not return the module, as it simply executes it.
+* Corresponds to the CLI behavior.
+*
+* @param options - The options for running the module.
+* @param args - Additional command-line arguments to pass to the module.
+*/
+async function unrunCli(options, args = []) {
+	const resolvedOptions = resolveOptions(options);
+	const outputChunk = await bundle(resolvedOptions);
+	const moduleUrl = writeModule(outputChunk.code, resolvedOptions);
+	let cliResult;
+	try {
+		cliResult = await execModule(moduleUrl, args);
+	} catch (error) {
+		throw new Error(`[unrun] Run failed (code length: ${outputChunk.code.length}): ${error.message}`);
+	}
+	cleanModule(moduleUrl);
+	return cliResult;
+}
+
+//#endregion
+export { unrunCli as n, unrunSync as r, unrun as t };

package/dist/sync/worker.d.ts

@@ -0,0 +1 @@
+export { };

package/dist/sync/worker.js

@@ -0,0 +1,50 @@
+import { t as unrun } from "../src-CRcGnzTd.js";
+import { runAsWorker } from "synckit";
+
+//#region src/sync/worker.ts
+function cloneForTransfer(value, seen = /* @__PURE__ */ new WeakMap()) {
+	if (typeof value === "function") throw new TypeError("[unrun] unrunSync cannot return functions");
+	if (value === null || typeof value !== "object") return value;
+	const objectValue = value;
+	if (seen.has(objectValue)) return seen.get(objectValue);
+	if (Array.isArray(value)) {
+		const clone$1 = [];
+		seen.set(objectValue, clone$1);
+		for (const item of value) clone$1.push(cloneForTransfer(item, seen));
+		return clone$1;
+	}
+	if (isModuleNamespace(value)) {
+		const clone$1 = Object.create(null);
+		seen.set(objectValue, clone$1);
+		for (const key of Object.keys(value)) {
+			const nestedValue = value[key];
+			clone$1[key] = cloneForTransfer(nestedValue, seen);
+		}
+		return clone$1;
+	}
+	if (typeof structuredClone === "function") try {
+		return structuredClone(value);
+	} catch (error) {
+		if (!isDataCloneError(error)) throw error;
+	}
+	const clone = {};
+	seen.set(objectValue, clone);
+	for (const [key, child] of Object.entries(value)) clone[key] = cloneForTransfer(child, seen);
+	return clone;
+}
+function isModuleNamespace(value) {
+	if (!value || typeof value !== "object") return false;
+	return Object.prototype.toString.call(value) === "[object Module]";
+}
+function isDataCloneError(error) {
+	if (!error || typeof error !== "object") return false;
+	if (!("name" in error)) return false;
+	return error.name === "DataCloneError";
+}
+runAsWorker(async (...args) => {
+	const options = args[0];
+	return cloneForTransfer(await unrun(options));
+});
+
+//#endregion
+export {  };

package/package.json

@@ -1,41 +1,102 @@
 {
   "name": "unrun",
-  "version": "0.1.0",
-  "description": "Better npm script runner",
+  "version": "0.2.1",
+  "description": "A tool to load and execute any JavaScript or TypeScript code at runtime.",
+  "type": "module",
+  "license": "MIT",
+  "homepage": "https://gugustinette.github.io/unrun/",
+  "bugs": {
+    "url": "https://github.com/Gugustinette/unrun/issues"
+  },
   "repository": {
-    "url": "egoist/unrun",
-    "type": "git"
+    "type": "git",
+    "url": "git+https://github.com/Gugustinette/unrun.git"
   },
+  "author": "Augustin Mercier <gugustinette@proton.me>",
+  "funding": "https://github.com/sponsors/Gugustinette",
   "files": [
-    "bin",
-    "lib"
+    "dist"
   ],
-  "bin": "bin/cli.js",
-  "scripts": {
-    "test": "npm run lint",
-    "lint": "xo"
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": "./dist/index.js",
+    "./package.json": "./package.json"
   },
-  "author": "egoist <0x142857@gmail.com>",
-  "license": "MIT",
-  "jest": {
-    "testEnvironment": "node"
+  "bin": {
+    "unrun": "./dist/cli.js"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@oxc-project/runtime": "^0.95.0",
+    "rolldown": "1.0.0-beta.45",
+    "synckit": "^0.11.11"
   },
   "devDependencies": {
-    "eslint-config-rem": "^3.0.0",
-    "jest-cli": "^18.1.0",
-    "xo": "^0.17.1"
+    "@sxzz/eslint-config": "^7.1.4",
+    "@sxzz/prettier-config": "^2.2.4",
+    "@types/node": "^24.3.0",
+    "acorn": "^8.15.0",
+    "bumpp": "^10.2.3",
+    "bundle-require": "^5.1.0",
+    "config": "^4.1.1",
+    "consola": "^3.4.2",
+    "defu": "^6.1.4",
+    "destr": "^2.0.5",
+    "esbuild": "^0.25.10",
+    "eslint": "^9.34.0",
+    "estree-walker": "^3.0.3",
+    "etag": "^1.8.1",
+    "fast-glob": "^3.3.3",
+    "giget": "^2.0.0",
+    "is-installed-globally": "^1.0.0",
+    "jiti": "^2.6.1",
+    "mime": "^4.1.0",
+    "moment-timezone": "^0.6.0",
+    "nano-jsx": "^0.2.0",
+    "preact": "^10.27.2",
+    "preact-render-to-string": "^6.6.1",
+    "prettier": "^3.6.2",
+    "react": "^19.1.1",
+    "react-dom": "^19.1.1",
+    "reflect-metadata": "^0.2.2",
+    "tinyexec": "^1.0.1",
+    "tsdown": "^0.15.9",
+    "tsx": "^4.20.6",
+    "typedoc": "^0.28.14",
+    "typedoc-plugin-markdown": "^4.9.0",
+    "typedoc-vitepress-theme": "^1.1.2",
+    "typescript": "^5.9.3",
+    "unconfig": "^7.3.3",
+    "vite": "^7.1.7",
+    "vitepress": "2.0.0-alpha.12",
+    "vitepress-plugin-group-icons": "^1.6.5",
+    "vitest": "4.0.2",
+    "vue": "^3.5.22",
+    "zod": "^4.1.8"
   },
-  "xo": {
-    "extends": "rem",
-    "esnext": true,
-    "envs": [
-      "jest"
-    ]
+  "engines": {
+    "node": ">=20.19.0"
   },
-  "dependencies": {
-    "cac": "^3.0.4",
-    "chalk": "^1.1.3",
-    "cross-spawn": "^5.1.0",
-    "inquirer": "^3.0.6"
+  "prettier": "@sxzz/prettier-config",
+  "scripts": {
+    "lint": "eslint --cache .",
+    "lint:fix": "pnpm run lint --fix",
+    "build": "tsdown",
+    "dev": "tsdown --watch",
+    "test": "vitest",
+    "test:run": "vitest run",
+    "test:update-fixtures": "node ./dist/cli.js ./scripts/update-fixtures.ts",
+    "benchmark": "tsdown -c benchmark/tsdown.config.ts && node ./benchmark/dist/benchmark.js",
+    "typecheck": "tsc --noEmit",
+    "format": "prettier --cache --write .",
+    "release": "bumpp && unotp pnpm publish",
+    "docs:dev": "vitepress dev docs",
+    "docs:build": "vitepress build docs",
+    "docs:preview": "vitepress preview docs",
+    "docs:generate-reference": "node ./dist/cli.js ./docs/.vitepress/scripts/generate-reference.ts"
   }
-}
+}

package/LICENSE

@@ -1,21 +0,0 @@
-The MIT License (MIT)
-
-Copyright (c) egoist <0x142857@gmail.com> (https://egoistian.com)
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.

package/bin/cli.js

@@ -1,60 +0,0 @@
-#!/usr/bin/env node
-/* eslint-disable import/no-dynamic-require */
-const path = require('path')
-const cac = require('cac')
-const chalk = require('chalk')
-const inq = require('inquirer')
-const startProcess = require('../lib/start-process')
-
-const cli = cac()
-
-cli.option('npm', 'use `npm run` instead of `yarn run`')
-
-cli.command('*', 'Run npm script', (input, flags) => {
-  const bin = flags.npm ? 'npm' : 'yarn'
-
-  if (input[0]) {
-    startProcess(bin, ['run', input[0]])
-    return
-  }
-
-  let pkg
-
-  try {
-    pkg = require(path.resolve('package.json'))
-  } catch (err) {
-    if (err.code !== 'MODULE_NOT_FOUND') {
-      console.error(chalk.red(err.stack))
-      process.exit(1)
-    }
-  }
-
-  const scripts = pkg && pkg.scripts
-  if (!scripts) {
-    console.error(chalk('> no npm scripts existing in current directory'))
-    process.exit(1)
-  }
-
-  const unrun = pkg.unrun || pkg.aboutScripts || {}
-  const choices = Object.keys(scripts).map(value => {
-    const description = unrun[value]
-    const script = scripts[value]
-    const displayScript = chalk.gray(` $ ${script}`)
-    return {
-      value,
-      name: description ? `${value}${displayScript}\n  ${chalk.gray(description)}` : value + displayScript,
-      short: description ? `${value}\n> ${chalk.gray(description)}` : value
-    }
-  })
-
-  inq.prompt([{
-    name: 'script',
-    type: 'list',
-    message: 'Choose a script:',
-    choices
-  }]).then(({ script }) => {
-    startProcess(bin, ['run', script])
-  })
-})
-
-cli.parse()

package/lib/start-process.js

@@ -1,24 +0,0 @@
-/* eslint-disable unicorn/no-process-exit */
-const spawn = require('cross-spawn')
-
-module.exports = function (bin, args) {
-  const proc = spawn(bin, args, { stdio: 'inherit', customFds: [0, 1, 2] })
-  proc.on('close', (code, signal) => {
-    if (code !== null) {
-      process.exit(code)
-    }
-    if (signal) {
-      if (signal === 'SIGKILL') {
-        process.exit(137)
-      }
-      console.log(`got signal ${signal}, exitting`)
-      process.exit(1)
-    }
-    process.exit(0)
-  })
-  proc.on('error', err => {
-    console.error(err)
-    process.exit(1)
-  })
-  return proc
-}