@n3bula/sandbox 0.0.1-alpha.1 → 0.0.1-alpha.3

package/README.md

@@ -1,6 +1,7 @@
 # `@n3bula/sandbox`
 
 ### Simple Sandbox for Node.js module quick test
+
 Just use for debug
 Debug the current process without restart process
 
@@ -18,14 +19,18 @@ pnpm add @n3bula/sandbox
 
 ```ts
 // server.ts
-import net from 'net';
-import { fileURLToPath } from 'node:url';
+import net from 'node:net';
 import { dirname, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
 import { createSandbox } from '@n3bula/sandbox';
+
 const PORT = 4000;
 const server = net.createServer();
+
+export type Server = typeof server;
+
 server.listen(PORT, () => console.log(`TCP server listening on ${PORT}`));
-server.on('error', err => console.error('server error', err));
 const destroy = () => {
   server.close();
   process.exit();
@@ -33,13 +38,36 @@ const destroy = () => {
 process.on('SIGINT', destroy);
 process.on('SIGTERM', destroy);
 
-createSandbox('sandbox', resolve(fileURLToPath(dirname(import.meta.url)), './client.ts'), { server });
+const file = resolve(fileURLToPath(dirname(import.meta.url)), './client.ts');
+createSandbox(
+  file,
+  {
+    server,
+  },
+  {
+    // name: 'sandbox',
+  },
+);
 ```
 
 ```ts
 // client.ts
-console.log(1); // change to console.log(server);
+import type { Server } from './server';
+
+declare const server: Server;
+console.log(server, typeof server);
 // will print current server instance without restart server
+
+const fs = _require(
+  'node:fs/promises',
+) as typeof import('node:fs/promises');
+
+const file = await fs.readFile('./example/client.ts', 'utf8');
+console.log('file :>>', file);
+
+const { echo } = _require('@n3bula/echo') as typeof import('@n3bula/echo');
+
+echo(globalThis);
 ```
 
 ## Author

package/dist/index.d.mts

@@ -1,4 +1,10 @@
+import { TsconfigRaw } from "esbuild";
+
 //#region src/sandbox.d.ts
-declare function createSandbox(name: string, watchFilePath: string, globals?: {}): void;
+type SandboxOptions = {
+  name?: string;
+  tsconfig?: string | TsconfigRaw;
+};
+declare function createSandbox(watchFilePath: string, globals?: {}, options?: SandboxOptions): void;
 //#endregion
 export { createSandbox };

package/dist/index.mjs

@@ -1,6 +1,10 @@
+import { createRequire } from "node:module";
+import { randomUUID } from "node:crypto";
 import vm from "node:vm";
 import EventEmitter from "node:events";
-import { readFile, stat, watch } from "node:fs";
+import { existsSync, readFileSync, stat, watch } from "node:fs";
+import { join } from "node:path";
+import { buildSync, transformSync } from "esbuild";
 import { echo } from "@n3bula/echo/node";
 //#region src/logger.ts
 const createLogger = (tag) => {
@@ -24,19 +28,47 @@ const logger = createLogger("@n3bula/sandbox");
 const DEBOUNCE_MS = 200;
 const READ_RETRY_MS = 100;
 const MAX_READ_RETRIES = 5;
+const DEFAULT_TSCONFIG = { compilerOptions: {
+	strict: false,
+	target: "ES2022"
+} };
+function findTsconfigFromProcessRoot() {
+	const tsconfigPath = join(process.cwd(), "tsconfig.json");
+	if (existsSync(tsconfigPath)) try {
+		return JSON.parse(readFileSync(tsconfigPath, "utf8"));
+	} catch {
+		return;
+	}
+}
 var FileWatcher = class extends EventEmitter {
 	timer = null;
 	lastStat = null;
 	readRetries = 0;
 	watcher;
-	constructor(filePath) {
+	tsOptions;
+	constructor(filePath, tsconfig) {
 		super();
 		this.filePath = filePath;
+		this.tsconfig = tsconfig;
+		this.normalizeTsOptions();
 		this.scheduleRead = this.scheduleRead.bind(this);
 		this.startWatch();
 	}
+	normalizeTsOptions() {
+		const tsconfig = findTsconfigFromProcessRoot();
+		if (tsconfig) {
+			this.tsOptions = { tsconfigRaw: tsconfig };
+			return;
+		}
+		if (typeof this.tsconfig === "string") try {
+			this.tsOptions = { tsconfigRaw: JSON.parse(this.tsconfig) };
+		} catch {
+			this.tsOptions = { tsconfig: this.tsconfig };
+		}
+		else this.tsOptions = { tsconfigRaw: DEFAULT_TSCONFIG };
+	}
 	safeReadAndNotify() {
-		readFile(this.filePath, "utf8", (err, data) => {
+		stat(this.filePath, (err, fileStat) => {
 			if (err) {
 				if (err.code === "ENOENT" && this.readRetries < MAX_READ_RETRIES) {
 					this.readRetries++;
@@ -47,13 +79,21 @@ var FileWatcher = class extends EventEmitter {
 				return;
 			}
 			this.readRetries = 0;
-			stat(this.filePath, (err2, fileStat) => {
-				if (!err2) {
-					if (this.lastStat && fileStat.mtimeMs === this.lastStat.mtimeMs && fileStat.size === this.lastStat.size) return;
-					this.lastStat = fileStat;
-				}
-				this.emit("change", data.split(/\r?\n/).filter((l) => !/^\s*\/\//.test(l)).map((l) => l.trim()).join(" "));
-			});
+			if (this.lastStat && fileStat.mtimeMs === this.lastStat.mtimeMs && fileStat.size === this.lastStat.size) return;
+			this.lastStat = fileStat;
+			const data = buildSync({
+				charset: "utf8",
+				entryPoints: [this.filePath],
+				format: "esm",
+				legalComments: "none",
+				minify: true,
+				minifyIdentifiers: false,
+				minifySyntax: false,
+				platform: "node",
+				write: false,
+				...this.tsOptions
+			}).outputFiles[0].contents;
+			this.emit("change", transformSync(data, {}).code);
 		});
 	}
 	scheduleRead() {
@@ -91,29 +131,53 @@ var FileWatcher = class extends EventEmitter {
 	}
 };
 //#endregion
+//#region src/require.ts
+const requireCache = /* @__PURE__ */ new Map();
+const _require = new Proxy(createRequire(import.meta.url), { apply(target, thisArg, argArray) {
+	const [id] = argArray;
+	const module = Reflect.apply(target, thisArg, argArray);
+	requireCache.set(_require.resolve(id), module);
+	return module;
+} });
+function sandboxRequireCleanup() {
+	requireCache.forEach((_, id) => {
+		if (!_require.cache[id]) return;
+		Reflect.deleteProperty(_require.cache, id);
+	});
+	requireCache.clear();
+}
+//#endregion
 //#region src/sandbox.ts
 function createContext(sandboxGlobals = {}) {
 	return vm.createContext({
-		console,
-		setTimeout,
-		setInterval,
-		clearTimeout,
+		_require,
 		clearInterval,
+		clearTimeout,
+		console,
 		fetch: typeof fetch !== "undefined" ? fetch : void 0,
+		setInterval,
+		setTimeout,
 		...sandboxGlobals
 	});
 }
-function createSandbox(name, watchFilePath, globals = {}) {
+function createSandbox(watchFilePath, globals = {}, options = {}) {
 	const sandboxContext = createContext({
 		...globals,
-		__sandbox_name: name
+		__sandbox_name: options.name || randomUUID()
 	});
 	function runCode(code) {
-		return new vm.Script(`(async () => { ${code} })()`).runInContext(sandboxContext, { timeout: 2e3 }).then((res) => res).catch((err) => {
-			logger.error(err.name, err.message);
+		return new Promise((resolve, reject) => {
+			try {
+				resolve(new vm.Script(`(async () => { ${code} })()`).runInContext(sandboxContext, { timeout: 2e3 }));
+				sandboxRequireCleanup();
+			} catch (error) {
+				reject(error);
+			}
+		}).then((res) => res).catch((err) => {
+			logger.error(err);
 		});
 	}
-	const watcher = new FileWatcher(watchFilePath);
+	const watcher = new FileWatcher(watchFilePath, options.tsconfig);
 	watcher.on("change", (code) => {
 		runCode(code);
 	});

package/dist/types.d.ts

@@ -0,0 +1,2 @@
+declare const __sandbox_name: string;
+declare const _require: NodeJS.Require;

package/package.json

@@ -1,14 +1,28 @@
 {
   "name": "@n3bula/sandbox",
-  "version": "0.0.1-alpha.1",
+  "version": "0.0.1-alpha.3",
   "description": "Simple Sandbox for Node.js module quick test",
   "type": "module",
-  "main": "dist/index.mjs",
-  "typings": "dist/index.d.mts",
   "keywords": [
     "sandbox",
     "node"
   ],
+  "main": "./dist/index.mjs",
+  "types": "./dist/index.d.mts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.mts",
+        "default": "./dist/index.mjs"
+      }
+    },
+    "./types": {
+      "types": "./dist/types.d.ts"
+    }
+  },
+  "files": [
+    "dist"
+  ],
   "contributors": [
     {
       "name": "Moriarty47",
@@ -35,10 +49,12 @@
     "tsdown": "^0.21.5"
   },
   "dependencies": {
+    "esbuild": "^0.25.12",
     "@n3bula/echo": "^0.1.0-alpha.4"
   },
+  "sideEffects": false,
   "scripts": {
-    "dev": "tsx --experimental-vm-modules example/server.ts",
+    "dev": "pnpm -C=example dev",
     "build": "tsdown"
   }
 }

package/example/client.ts

@@ -1 +0,0 @@
-console.log(server);

package/example/server.ts

@@ -1,20 +0,0 @@
-import net from 'net';
-import { fileURLToPath } from 'node:url';
-import { dirname, resolve } from 'node:path';
-
-import { createSandbox } from '../src';
-
-const PORT = 4000;
-const server = net.createServer();
-server.listen(PORT, () => console.log(`TCP server listening on ${PORT}`));
-const destroy = () => {
-  server.close();
-  process.exit();
-};
-process.on('SIGINT', destroy);
-process.on('SIGTERM', destroy);
-
-const file = resolve(fileURLToPath(dirname(import.meta.url)), './client.ts');
-createSandbox('sandbox', file, {
-  server,
-});

package/src/file-watcher.ts

@@ -1,90 +0,0 @@
-import EventEmitter from 'node:events';
-import { FSWatcher, readFile, stat, Stats, watch } from 'node:fs';
-
-import { logger } from './logger';
-
-const DEBOUNCE_MS = 200;
-const READ_RETRY_MS = 100;
-const MAX_READ_RETRIES = 5;
-
-export class FileWatcher extends EventEmitter {
-  timer: NodeJS.Timeout | null = null;
-  lastStat: Stats | null = null;
-  readRetries = 0;
-  watcher!: FSWatcher;
-  constructor(public filePath: string) {
-    super();
-    this.scheduleRead = this.scheduleRead.bind(this);
-    this.startWatch();
-  }
-
-  safeReadAndNotify() {
-    readFile(this.filePath, 'utf8', (err, data) => {
-      if (err) {
-        if (err.code === 'ENOENT' && this.readRetries < MAX_READ_RETRIES) {
-          this.readRetries++;
-          setTimeout(this.safeReadAndNotify, READ_RETRY_MS);
-          return;
-        }
-        logger.error('Read error:', err.code, err.message);
-        return;
-      }
-      this.readRetries = 0;
-      stat(this.filePath, (err2, fileStat) => {
-        if (!err2) {
-          if (this.lastStat && fileStat.mtimeMs === this.lastStat.mtimeMs && fileStat.size === this.lastStat.size)
-            return;
-          this.lastStat = fileStat;
-        }
-        this.emit(
-          'change',
-          data
-            .split(/\r?\n/)
-            .filter(l => !/^\s*\/\//.test(l))
-            .map(l => l.trim())
-            .join(' '),
-        );
-      });
-    });
-  }
-
-  scheduleRead() {
-    if (this.timer) clearTimeout(this.timer);
-    this.timer = setTimeout(() => {
-      this.timer = null;
-      this.safeReadAndNotify();
-    }, DEBOUNCE_MS);
-  }
-
-  startWatch() {
-    try {
-      const watcher = watch(this.filePath, { encoding: 'utf8', persistent: true }, this.scheduleRead);
-
-      watcher.on('error', err => {
-        logger.error('fs.watch error', err);
-        if (watcher) {
-          try {
-            watcher.close();
-          } catch {}
-        }
-      });
-
-      stat(this.filePath, (err, fileStat) => {
-        if (!err) this.lastStat = fileStat;
-      });
-
-      logger('Watching', this.filePath);
-      this.watcher = watcher;
-    } catch (error: any) {
-      logger.error('fs.watch error', error.message);
-    }
-  }
-
-  destroy() {
-    if (this.watcher && typeof this.watcher.close === 'function') {
-      try {
-        this.watcher.close();
-      } catch {}
-    }
-  }
-}

package/src/index.ts

@@ -1 +0,0 @@
-export { createSandbox } from './sandbox';

package/src/logger.ts

@@ -1,28 +0,0 @@
-import { echo } from '@n3bula/echo/node';
-
-export const createLogger = (tag?: string) => {
-  const logger = ((...msg: any[]) => {
-    tag ? echo.fg.cyan(tag, ...msg) : echo.fg.cyan(...msg);
-  }) as {
-    (...msg: any[]): void;
-    info(...msg: any[]): void;
-    warn(...msg: any[]): void;
-    error(...msg: any[]): void;
-  };
-
-  logger.info = (...msg: any[]) => {
-    tag ? echo.fg('#66b5ff')(tag, ...msg) : echo.fg('#66b5ff')(...msg);
-  };
-
-  logger.warn = (...msg: any[]) => {
-    tag ? echo.fg('#ff9966')(tag, ...msg) : echo.fg('#ff9966')(...msg);
-  };
-
-  logger.error = (...msg: any[]) => {
-    tag ? echo.fg.orangeRed(tag, ...msg) : echo.fg.orangeRed(...msg);
-  };
-
-  return logger;
-};
-
-export const logger = createLogger('@n3bula/sandbox');

package/src/sandbox.ts

@@ -1,46 +0,0 @@
-import vm from 'node:vm';
-
-import { FileWatcher } from './file-watcher';
-import { logger } from './logger';
-
-function createContext(sandboxGlobals = {}) {
-  const context = vm.createContext({
-    console,
-    setTimeout,
-    setInterval,
-    clearTimeout,
-    clearInterval,
-    fetch: typeof fetch !== 'undefined' ? fetch : undefined,
-    ...sandboxGlobals,
-  });
-  return context;
-}
-
-export function createSandbox(name: string, watchFilePath: string, globals = {}) {
-  const sandboxContext = createContext({
-    ...globals,
-    __sandbox_name: name,
-  });
-
-  function runCode(code: string) {
-    const script = new vm.Script(`(async () => { ${code} })()`);
-    const result: Promise<any> = script.runInContext(sandboxContext, { timeout: 2000 });
-    return result
-      .then(res => res)
-      .catch(err => {
-        logger.error(err.name, err.message);
-      });
-  }
-
-  const watcher = new FileWatcher(watchFilePath);
-  watcher.on('change', code => {
-    runCode(code);
-  });
-
-  const destroy = () => {
-    watcher.destroy();
-    process.exit();
-  };
-  process.on('SIGINT', destroy);
-  process.on('SIGTERM', destroy);
-}

package/src/wasted-module.ts

@@ -1,172 +0,0 @@
-import vm from 'node:vm';
-import Module from 'node:module';
-import { fileURLToPath, pathToFileURL } from 'node:url';
-import { dirname, resolve } from 'node:path';
-import { existsSync } from 'node:fs';
-import { readFile } from 'node:fs/promises';
-import { PROTOCOL_FILE, PROTOCOL_NODE, resolvedProtocols } from './utils';
-
-function createContext(sandboxGlobals = {}) {
-  const context = vm.createContext({
-    console,
-    setTimeout,
-    setInterval,
-    clearTimeout,
-    clearInterval,
-    fetch: typeof fetch !== 'undefined' ? fetch : undefined,
-    ...sandboxGlobals,
-  });
-  return context;
-}
-
-export function createSandbox(name: string, globals = {}) {
-  const memoryModules = new Map<string, { code: string; mtime: number }>();
-
-  const moduleInstances = new Map<string, vm.Module>();
-
-  const sandboxContext = createContext({
-    ...globals,
-    __sandbox_name: name,
-    __node_import_fallback: (id: string) => {
-      try {
-        return Module.createRequire(import.meta.url)(id);
-      } catch (error) {
-        // try without node: prefix
-        return Module.createRequire(import.meta.url)(id);
-      }
-    },
-  });
-
-  async function resolveSpecifier(specifier: string, referrer?: string) {
-    const isFileProtocol = !!(referrer && referrer.startsWith(PROTOCOL_FILE));
-    try {
-      const url = new URL(specifier, isFileProtocol ? referrer : undefined);
-      if (resolvedProtocols.includes(url.protocol)) {
-        return url.toString();
-      }
-    } catch (error) {
-      // not a URL, other resolve solution
-    }
-
-    if (memoryModules.has(specifier)) return specifier;
-
-    try {
-      const require = Module.createRequire(isFileProtocol ? referrer : pathToFileURL(`${process.cwd()}/`).toString());
-      const resolved = require.resolve(specifier);
-      return pathToFileURL(resolved).toString();
-    } catch (error) {
-      // fallback: try resolving as relative to referrer filesystem path
-      if (isFileProtocol) {
-        const refPath = fileURLToPath(referrer);
-        const candidate = resolve(dirname(refPath), specifier);
-        if (existsSync(candidate)) {
-          const final = pathToFileURL(candidate).toString();
-          return final;
-        }
-      }
-      // last resort: return specifier as-is, link may fail
-      return specifier;
-    }
-  }
-
-  async function loadSource(resolved: string) {
-    const memoryModule = memoryModules.get(resolved);
-    if (memoryModule) return { source: memoryModule.code, url: resolved };
-
-    if (resolved.startsWith(PROTOCOL_FILE)) {
-      const filePath = fileURLToPath(resolved);
-      const code = await readFile(filePath, 'utf8');
-      return { source: code, url: resolved };
-    }
-
-    if (resolved.startsWith(PROTOCOL_NODE)) {
-      const pkg = resolved.slice(PROTOCOL_NODE.length);
-      const code = `export default globalThis.__node_import_fallback('${pkg}');\nexport const __esModule = true;`;
-      return { source: code, url: resolved };
-    }
-
-    try {
-      const code = await readFile(resolved, 'utf8');
-      return { source: code, url: resolved };
-    } catch {
-      // fallback: create a wrapper that imports via dynamic import
-      const code = `export default await import(${JSON.stringify(resolved)});\n`;
-      return { source: code, url: resolved };
-    }
-  }
-
-  async function linker(specifier: string, referencingModule: vm.Module) {
-    const refUrl = (('identifier' in referencingModule && referencingModule.identifier) as string) || undefined;
-    const resolved = await resolveSpecifier(specifier, refUrl);
-    const { source, url } = await loadSource(resolved);
-
-    const moduleInstance = moduleInstances.get(url);
-    if (moduleInstance) return moduleInstance;
-
-    const module = new vm.SourceTextModule(source, {
-      context: sandboxContext,
-      identifier: url,
-      initializeImportMeta: (meta, module) => (meta.url = module.identifier),
-    });
-
-    moduleInstances.set(url, module);
-
-    // link dependencies recursively inside vm's linker; vm.Module.link willcall our linker for each import
-    await module.link(linker);
-    return module;
-  }
-
-  function registerModule(specifier: string, code: string) {
-    memoryModules.set(specifier, { code, mtime: Date.now() });
-    // invalidate instance cache
-    moduleInstances.delete(specifier);
-  }
-
-  function unnregisterModule(specifier: string) {
-    memoryModules.delete(specifier);
-    moduleInstances.delete(specifier);
-  }
-
-  async function runModule(
-    code: string,
-    specifier: string = `mem://${Date.now()}-${Math.random().toString(36).slice(2)}`,
-    globals = {},
-  ) {
-    Object.assign(sandboxContext, globals);
-    registerModule(specifier, code);
-
-    const resolved = await resolveSpecifier(specifier);
-    const { source, url } = await loadSource(resolved);
-
-    const module = new vm.SourceTextModule(source, {
-      context: sandboxContext,
-      identifier: url,
-      initializeImportMeta: (meta, m) => (meta.url = m.identifier),
-    });
-
-    moduleInstances.set(url, module);
-
-    await module.link(linker);
-
-    const result = await module.evaluate();
-    return {
-      module,
-      namespace: module.namespace,
-      status: module.status,
-      evaluationResult: result,
-    };
-  }
-
-  function hotReload(specifier: string, newCode: string) {
-    unnregisterModule(specifier);
-    registerModule(specifier, newCode);
-    return runModule(newCode, specifier);
-  }
-
-  return {
-    registerModule,
-    unnregisterModule,
-    runModule,
-    hotReload,
-  };
-}

package/src/wasted-socket.ts

@@ -1,90 +0,0 @@
-import net, { Socket } from 'node:net';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { IS_WIN } from './utils';
-import { chmodSync, existsSync, unlinkSync } from 'node:fs';
-import { logger } from './logger';
-
-function getSocketPath(name: string = 'n3bula-sandbox') {
-  if (IS_WIN) {
-    const pipeName = name.replace(/[\\/:\*\?"<>\|]/g, '_');
-    return `\\\\.\\pipe\\${pipeName}`;
-  }
-  return join(tmpdir(), `${name}.sock`);
-}
-
-function cleanupSocketFile(socketPath: string) {
-  if (IS_WIN) return;
-  try {
-    if (existsSync(socketPath)) unlinkSync(socketPath);
-  } catch {}
-}
-
-export async function createSocketServer(name: string, connectionListener: (socket: Socket) => void) {
-  const socketPath = getSocketPath(name);
-  cleanupSocketFile(socketPath);
-
-  const server = net.createServer(socket => {
-    socket.on('end', () => socket.end());
-    socket.on('close', () => logger('server closed'));
-    socket.on('error', err => logger.error('server', err));
-    connectionListener(socket);
-  });
-
-  server.listen(socketPath, () => {
-    logger('Listening on', socketPath);
-    if (IS_WIN) return;
-    try {
-      chmodSync(socketPath, 0o600);
-    } catch {}
-  });
-
-  const cleanup = () => {
-    server.close();
-    cleanupSocketFile(socketPath);
-  };
-  const destroy = () => {
-    cleanup();
-    process.exit();
-  };
-  process.on('exit', cleanup);
-  process.on('SIGINT', destroy);
-  process.on('SIGTERM', destroy);
-
-  return { server, path: socketPath };
-}
-
-function connectSocket(name: string, onConnect?: (socket: Socket) => void) {
-  const socketPath = getSocketPath(name);
-  return new Promise<string>((resolve, reject) => {
-    const client = net.createConnection(socketPath, () => onConnect?.(client));
-    client.setEncoding('utf8');
-
-    client.on('close', () => logger('client closed'));
-    client.on('error', err => logger.error('client', err));
-
-    let resp = '';
-    client.on('data', d => (resp += d));
-
-    client.on('end', () => {
-      try {
-        resolve(JSON.parse(resp));
-      } catch (e) {
-        reject(e);
-      }
-      client.end();
-    });
-  });
-}
-
-export function clientSend(name: string, code: string) {
-  return connectSocket(name, socket => {
-    socket.write(
-      `${code
-        .split(/\r?\n/)
-        .filter(l => !/^\s*\/\//.test(l))
-        .map(l => l.trim())
-        .join(' ')}\n`,
-    );
-  });
-}

package/src/wasted-utils.ts

@@ -1,4 +0,0 @@
-export const PROTOCOL_FILE = 'file:';
-export const PROTOCOL_NODE = 'node:';
-export const resolvedProtocols = [PROTOCOL_NODE, PROTOCOL_FILE, 'data:', 'http:', 'https:'];
-export const IS_WIN = process.platform === 'win32';

package/tsconfig.json

@@ -1,21 +0,0 @@
-{
-  "compilerOptions": {
-    "rootDir": ".",
-    "target": "ES2022",
-    "lib": ["ES2022"],
-    "module": "es2022",
-    "types": ["node"],
-    "skipLibCheck": true,
-    "moduleResolution": "bundler",
-    "noEmit": true,
-    "esModuleInterop": true,
-    /* Linting */
-    "strict": true,
-    "noUnusedLocals": true,
-    "noUnusedParameters": true,
-    "erasableSyntaxOnly": false,
-    "noFallthroughCasesInSwitch": true,
-    "noUncheckedSideEffectImports": true
-  },
-  "include": ["tsdown.config.ts", "src", "example"]
-}

package/tsdown.config.ts

@@ -1,5 +0,0 @@
-import { defineConfig } from 'tsdown';
-
-export default defineConfig({
-  entry: ['./src/index.ts'],
-});