vivth 1.3.2 → 1.3.4

package/README.src.md

@@ -10,6 +10,9 @@ npm i vivth
 
 - `vivth` are intended to be a collections of usefull `primitives`, and not to be directly used as
   underlying framework;
+- `vivth` are leaning to `esm(.mjs)+jsdoc` first;
+  > - some functionality "might need" work around if you are using other than `esm+jsdoc`;
+  > - `CompileJS`, `ESBundler` expose `format` option for some leeway for `commonJS`;
 - completely `JSruntime` agnostic:
   > - instead of `vivth` trying to guess, all runtime specific API should be provided by dev;
 - contains helpers to help you write data driven javascript program, including:
@@ -28,6 +31,11 @@ npm i vivth
   >   > - abstracted via `esbuild`;
   > - opionated `compiler`;
   >   > - abstracted via `pkg`, `deno`, and `bun`;
+- when using runtime that doesn't provide specific common modules golbally(like `Deno`), dev should
+  import it statically from `node:module_name`, example:
+  ```js
+  import process from 'node:process';
+  ```
 
 ## versions:
 
@@ -40,3 +48,5 @@ npm i vivth
 
 - `1.3.x:beta`:
   > - type should now fully fixed, even with strict ts check;
+- `1.3.3+:beta`:
+  > - added class `Dev` for testing and `Dev`/`preBundled` only code block;

package/bun.lock

@@ -14,7 +14,9 @@
       "devDependencies": {
         "@types/bun": "latest",
         "concurrently": "^9.2.1",
+        "prettier": "^3.6.2",
         "typescript": "^5.9.2",
+        "vivth": "link:vivth",
       },
     },
   },
@@ -261,6 +263,8 @@
 
     "prebuild-install": ["prebuild-install@7.1.1", "", { "dependencies": { "detect-libc": "^2.0.0", "expand-template": "^2.0.3", "github-from-package": "0.0.0", "minimist": "^1.2.3", "mkdirp-classic": "^0.5.3", "napi-build-utils": "^1.0.1", "node-abi": "^3.3.0", "pump": "^3.0.0", "rc": "^1.2.7", "simple-get": "^4.0.0", "tar-fs": "^2.0.0", "tunnel-agent": "^0.6.0" }, "bin": { "prebuild-install": "bin.js" } }, "sha512-jAXscXWMcCK8GgCoHOfIr0ODh5ai8mj63L2nWrjuAgXE6tDyYGnx4/8o/rCgU+B4JSyZBKbeZqzhtwtC3ovxjw=="],
 
+    "prettier": ["prettier@3.6.2", "", { "bin": { "prettier": "bin/prettier.cjs" } }, "sha512-I7AIg5boAr5R0FFtJ6rCfD+LFsWHp81dolrFD8S79U9tb8Az2nGrJncnMSnys+bpQJfRUzqs9hnA81OAA3hCuQ=="],
+
     "process-nextick-args": ["process-nextick-args@2.0.1", "", {}, "sha512-3ouUOpQhtgrbOa17J7+uxOTpITYWaGP7/AhoR3+A+/1e9skrzelGi/dXzEYyvbxubEF6Wn2ypscTKiKJFFn1ag=="],
 
     "progress": ["progress@2.0.3", "", {}, "sha512-7PiHtLll5LdnKIMw100I+8xJXR5gW2QwWYkT6iJva0bXitZKa/XMrSbdmg3r2Xnaidz9Qumd0VPaMrZlF9V9sA=="],
@@ -335,6 +339,8 @@
 
     "util-deprecate": ["util-deprecate@1.0.2", "", {}, "sha512-EPD5q1uXyFxJpCrLnCc1nHnq3gOa6DZBocAIiI2TaSCA7VCJ1UJDMagCzIkXNsUYfD1daK//LTEQ8xiIbrHtcw=="],
 
+    "vivth": ["vivth@link:vivth", {}],
+
     "webidl-conversions": ["webidl-conversions@3.0.1", "", {}, "sha512-2JAn3z8AR6rjK8Sm8orRC0h/bcl/DqL7tRPdGZ4I1CjdF+EaMLmYxBHyXuKL849eucPFhvBoxMsflfOb8kxaeQ=="],
 
     "whatwg-url": ["whatwg-url@5.0.0", "", { "dependencies": { "tr46": "~0.0.3", "webidl-conversions": "^3.0.0" } }, "sha512-saE57nupxk6v3HY35+jzBwYa0rKSy0XR8JSxZPwgLr7ys0IBzhGviA1/TUGJLmSVqs8pb9AnvICXEuOHLprYTw=="],

package/index.mjs

@@ -6,6 +6,7 @@
  * this library is made and distributed under MIT license;
  */
 
+export { ToBundledJSPlugin } from './src/bundler/adds/ToBundledJSPlugin.mjs';
 export { CompileJS } from './src/bundler/CompileJS.mjs';
 export { CreateESPlugin } from './src/bundler/CreateESPlugin.mjs';
 export { EsBundler } from './src/bundler/EsBundler.mjs';
@@ -26,13 +27,18 @@ export { SafeExit } from './src/class/SafeExit.mjs';
 export { Setup } from './src/class/Setup.mjs';
 export { Signal } from './src/class/Signal.mjs';
 export { WorkerMainThread } from './src/class/WorkerMainThread.mjs';
+export { WorkerResult } from './src/class/WorkerResult.mjs';
+export { WorkerThread } from './src/class/WorkerThread.mjs';
 export { Base64URL } from './src/common/Base64URL.mjs';
 export { Base64URLFromFile } from './src/common/Base64URLFromFile.mjs';
+export { Dev } from './src/common/Dev.mjs';
 export { EventNameSpace } from './src/common/EventNameSpace.mjs';
+export { Trace } from './src/common/Trace.mjs';
 export { JSautoDOC } from './src/doc/JSautoDOC.mjs';
 export { CreateImmutable } from './src/function/CreateImmutable.mjs';
 export { EventCheck } from './src/function/EventCheck.mjs';
 export { EventObject } from './src/function/EventObject.mjs';
+export { GetNamedImportAlias } from './src/function/GetNamedImportAlias.mjs';
 export { GetRuntime } from './src/function/GetRuntime.mjs';
 export { IsAsync } from './src/function/IsAsync.mjs';
 export { LazyFactory } from './src/function/LazyFactory.mjs';
@@ -41,12 +47,12 @@ export { Try } from './src/function/Try.mjs';
 export { TryAsync } from './src/function/TryAsync.mjs';
 export { TrySync } from './src/function/TrySync.mjs';
 export { TsToMjs } from './src/function/TsToMjs.mjs';
-export { WorkerResult } from './src/class/WorkerResult.mjs';
-export { WorkerThread } from './src/class/WorkerThread.mjs';
-export { ToBundledJSPlugin } from './src/bundler/adds/ToBundledJSPlugin.mjs';
 /**
  * @typedef {import('./src/types/AnyButUndefined.mjs').AnyButUndefined} AnyButUndefined
  */
+/**
+ * @typedef {import('./src/types/DevTestCB.mjs').DevTestCB} DevTestCB
+ */
 /**
  * @typedef {import('./src/types/ExtnameType.mjs').ExtnameType} ExtnameType
  */
@@ -74,4 +80,7 @@ export { ToBundledJSPlugin } from './src/bundler/adds/ToBundledJSPlugin.mjs';
  */
 /**
  * @typedef {import('./src/types/Runtime.mjs').Runtime} Runtime
+ */
+/**
+ * @typedef {import('./src/types/VivthDevCodeBlockStringType.mjs').VivthDevCodeBlockStringType} VivthDevCodeBlockStringType
  */

package/package.json

@@ -1,15 +1,17 @@
 {
 	"name": "vivth",
-	"version": "1.3.2",
+	"version": "1.3.4",
 	"description": "library primitives",
 	"main": "index.mjs",
 	"types": "./types/index.d.mts",
 	"devDependencies": {
 		"@types/bun": "latest",
 		"concurrently": "^9.2.1",
-		"typescript": "^5.9.2"
+		"typescript": "^5.9.2",
+		"vivth": "link:vivth"
 	},
 	"dependencies": {
+		"prettier": "^3.6.2",
 		"@types/mime-types": "^3.0.1",
 		"chokidar": "^4.0.3",
 		"esbuild": "^0.25.9",

package/src/bundler/CompileJS.mjs

@@ -10,6 +10,7 @@ import { EsBundler } from './EsBundler.mjs';
 import { FileSafe } from '../class/FileSafe.mjs';
 import { TryAsync } from '../function/TryAsync.mjs';
 import { FSInlineAnalyzer } from './FSInlineAnalyzer.mjs';
+import { removeVivthDevCodeBlock } from './adds/ToBundledJSPlugin.mjs';
 
 /**
  * @typedef {'win32' | 'linux' | 'darwin' | string} PlatformKey
@@ -67,9 +68,9 @@ const getBinaryExtension = () => {
 /**
  * @description
  * - function to compile `.ts`|`.mts`|`.mjs` file, into a single executable;
- * - also generate js representation;
+ * - also generate js representation of the `bundled` version of the target;
  * - uses [pkg](https://www.npmjs.com/package/pkg), [bun](https://bun.com/docs/bundler/executables), and [deno](https://docs.deno.com/runtime/reference/cli/compile/) compiler under the hood;
- * >- they are used only as packaging agent, and doesn't necessarily supports their advanced feature, such as, assets bundling(use [FSInline](#fsinline) instead);
+ * >- they are used only as packaging/compiler agent, and doesn't necessarily supports their advanced feature, such as, assets bundling(use [`FSInline`](#fsinline) instead);
  * >- `WorkerThread` will be converted to inline using `FSInline` too;
  *
  * !!!WARNING!!!
@@ -88,8 +89,12 @@ const getBinaryExtension = () => {
  * @param {string} options.entryPoint
  * - need to be manually prefixed;
  * @param {BufferEncoding} [options.encoding]
- * - write and read encoding for the sources;
+ * - read and write encoding for the sources;
  * - default: `utf-8`;
+ * @param {(entryPointContent:string)=>string} [options.preprocessEntryPoint]
+ * - to modify entry point before bundling;
+ * - `entryPointContent` is the original string of the entry point;
+ * - returned value then passed to `ESBundler`;
  * @param {boolean} options.minifyFirst
  * - minify the bundle before compilation;
  * @param {string} options.outDir
@@ -109,45 +114,71 @@ const getBinaryExtension = () => {
  * bundledJSFile:string|undefined
  * }>>}
  * @example
+ * import process from 'node:process';
  * import { join } from 'node:path';
  *
- * import { CompileJS, Paths } from 'vivth';
+ * import { CompileJS, Console, Paths, Setup } from 'vivth';
+ *
+ * const { paths, safeExit } = Setup;
+ * new paths({
+ * 	root: process.env.INIT_CWD ?? process.cwd(),
+ * });
+ * new safeExit({
+ * 	eventNames: ['SIGINT', 'SIGTERM'],
+ * 	terminator: () => process.exit(0),
+ * 	listener: (eventName) => {
+ * 		process.once(eventName, function () {
+ * 			if (!safeExit.instance) {
+ * 				return;
+ * 			}
+ * 			safeExit.instance.exiting.correction(true);
+ * 			Console.log(`safe exit via "${eventName}"`);
+ * 		});
+ * 	},
+ * });
+ * const pathRoot = Paths.root;
+ * if (pathRoot) {
+ * 	const [[, error], [, errorbun]] = await Promise.all([
+ * 		CompileJS({
+ * 			entryPoint: join(pathRoot, '/dev/myEntryPoint.mjs'),
+ * 			minifyFirst: true,
+ * 			outDir: join(pathRoot, '/dev-pkg/'),
+ * 			compiler: 'pkg',
+ * 			compilerArguments: {
+ * 				target: 'node18-win-x64',
+ * 			},
+ * 			encoding: 'utf-8',
+ * 		}),
+ * 		await CompileJS({
+ * 			entryPoint: join(pathRoot, '/dev/myEntryPoint.mjs'),
+ * 			minifyFirst: true,
+ * 			outDir: join(pathRoot, '/dev-bun/'),
+ * 			compiler: 'bun',
+ * 			compilerArguments: {
+ * 				target: 'bun-win-x64',
+ * 			},
+ * 			encoding: 'utf-8',
+ * 		}),
+ * 	]);
+ * 	if (error || errorbun) {
+ * 		Console.error({ error, errorbun });
+ * 	}
+ * }
  *
- * const [[resultPkg, errorPkg], [resultBun, errorBun]] = await Promise.all([
- * 	CompileJS({
- * 		entryPoint: join(Paths.root, '/dev'),
- * 		minifyFirst: true,
- * 		outDir: join(Paths.root, '/dev-pkg'),
- * 		compiler: 'pkg',
- * 		compilerArguments: {
- * 			target: ['node18-win-x64'],
- * 		},
- * 		esBundlerPlugins: [],
- * 	}),
- * 	CompileJS({
- * 		entryPoint: join(Paths.root, '/dev'),
- * 		minifyFirst: true,
- * 		outDir: join(Paths.root, '/dev-pkg'),
- * 		compiler: 'bun',
- * 		compilerArguments: {
- * 			target: ['bun-win-x64'],
- * 		},
- * 		esBundlerPlugins: [],
- * 	}),
- * ])
  */
 export async function CompileJS({
 	entryPoint,
 	minifyFirst,
 	encoding = 'utf-8',
 	outDir,
+	preprocessEntryPoint = undefined,
 	compiler = undefined,
 	compilerArguments = {},
 	esBundlerPlugins = [],
 }) {
 	return await TryAsync(async () => {
 		/**
-		 * @type {'cjs'|'esm'|'iife'}
+		 * @type {'cjs'|'esm'}
 		 */
 		let format;
 		switch (compiler) {
@@ -174,7 +205,10 @@ export async function CompileJS({
 					`extention mismatch: "${extOfSource}", should be one of:".mjs"|".mts"|".ts"`
 				);
 		}
-		const sourceText = await readFile(entryPoint, { encoding });
+		let sourceText = removeVivthDevCodeBlock(await readFile(entryPoint, { encoding }));
+		if (preprocessEntryPoint) {
+			sourceText = preprocessEntryPoint(sourceText);
+		}
 		const [bundledPrep, errorPrep] = await EsBundler(
 			{
 				content: sourceText,

package/src/bundler/EsBundler.mjs

@@ -17,7 +17,7 @@ import { externals } from './adds/externals.mjs';
  * - the code can also uses composites from the result from multiple readFiles;
  * @param {string} options.root
  * - use dirname of said fileString path;
- * @param {'.mts'|'.ts'|'.mjs'} options.extension
+ * @param {'.mts'|'.ts'|'.mjs'|'.cjs'} options.extension
  * @param {boolean} [options.withBinHeader]
  * @param {Omit<Parameters<build>[0],
  * 'entryPoints'|'bundle'|'write'|'sourcemap'>
@@ -51,6 +51,7 @@ export async function EsBundler(
 				loader = 'ts';
 				break;
 			case '.mjs':
+			case '.cjs':
 				loader = 'js';
 				break;
 			default:

package/src/bundler/FSInline.mjs

@@ -7,8 +7,11 @@ import { Paths } from '../class/Paths.mjs';
 
 /**
  * @description
- * - class helper to inline file;
+ * - class helper to inline files;
+ * >- as `type: "buffer"`;
  * - use only if you are planning to use [CompileJS](#compilejs);
+ * >- the class static methods don't obfuscate target file;
+ * >- don't embed any sensitive content using this methods of this class;
  */
 export class FSInline {
 	/**
@@ -19,6 +22,9 @@ export class FSInline {
 	 * @param {string} filePathFromProject
 	 * - doesn't require prefix;
 	 * @returns {Promise<Buffer<ArrayBuffer>>}
+	 * - dev: returns `ArrayBuffer`;
+	 * - bundled: embed the `ArrayBuffer` of file, which then returned;
+	 * >- `Dev` will be cleaned up;
 	 * @example
 	 * import { FSInline } from 'vivth';
 	 *
@@ -35,6 +41,7 @@ export class FSInline {
 	/**
 	 * @description
 	 * - declare entrypoint of file inlining, include all files on `dir` and `subdir` that match the `fileRule`;
+	 * - consider this as inline assets embed/bundler;
 	 * @param {string} dirPathFromProject
 	 * - doesn't require prefix;
 	 * @param {RegExp} fileRule

package/src/bundler/FSInlineAnalyzer.mjs

@@ -8,6 +8,7 @@ import { LitExp } from '../class/LitExp.mjs';
 import { TryAsync } from '../function/TryAsync.mjs';
 import { FSInline } from './FSInline.mjs';
 import { EsBundler } from './EsBundler.mjs';
+import { removeVivthDevCodeBlock } from './adds/ToBundledJSPlugin.mjs';
 
 /**
  * @param {string} str
@@ -25,6 +26,7 @@ const hydrateRegex = (str) => {
 /**
  * @description
  * - collections of static method to analyze content for `FSInline`;
+ * - mostly used internally;
  */
 export class FSInlineAnalyzer {
 	/**
@@ -45,25 +47,26 @@ export class FSInlineAnalyzer {
 	 */
 	static finalContent = async (content, format) => {
 		return await TryAsync(async () => {
+			content = removeVivthDevCodeBlock(content);
 			const [literalFile, errorPrepareFile] = LitExp.prepare({
-				FSInline: /\w*/,
+				FSInline: /[\w][\w\d]*/,
 				method: /\.vivthFSInlineFile\s*?\(\s*?['"]/,
 				path: false,
-				closing: /['"]\s*?\)(?:;|)/,
+				closing: /['"]\s*?\)/,
 			});
 			const [literalWorker, errorPreparWorker] = LitExp.prepare({
-				ref: /\w*/,
+				ref: /[\w][\w\d]*/,
 				method: /\.newVivthWorker\s*?\(\s*?['"]/,
 				path: false,
-				closing: /['"]/,
+				closing: /['"]\s*\)/,
 			});
 			const [literalDir, errorPrepareDir] = LitExp.prepare({
-				FSInline: /\w*/,
+				FSInline: /[\w][\w\d]*/,
 				method: /\.vivthFSInlineDir\s*?\(\s*?['"]/,
 				path: false,
-				methodClosing: /['"]\s*?,/,
+				methodClosing: /['"]\s*?,\s*/,
 				rule: false,
-				functionClosing: /\)(?:;|)/,
+				functionClosing: /\s*?\)/,
 			});
 			if (errorPrepareFile || errorPrepareDir || errorPreparWorker) {
 				throw { errorPrepareFile, errorPrepareDir, errorPreparWorker };
@@ -71,7 +74,6 @@ export class FSInlineAnalyzer {
 			const templateFile = literalFile`${'FSInline'}${'method'}${'path'}${'closing'}`;
 			const templateWorker = literalWorker`${'ref'}${'method'}${'path'}${'closing'}`;
 			const templateDir = literalDir`${'FSInline'}${'method'}${'path'}${'methodClosing'}${'rule'}${'functionClosing'}`;
-
 			const [resultMatchingFile, errorMatchingFile] = templateFile.evaluate.matchedAllAndGrouped(
 				content,
 				{
@@ -94,19 +96,47 @@ export class FSInlineAnalyzer {
 			if (errorMatchingFile || errorMatchingDir || errorMatchingWorker) {
 				throw { errorMatchingFile, errorMatchingDir, errorMatchingWorker };
 			}
-			const {
-				result: { named: namedFile },
-			} = resultMatchingFile;
 			if (Paths.root === undefined) {
 				throw new Error('Path.root undefined');
 			}
+			const {
+				result: { named: namedFile },
+			} = resultMatchingFile;
 			for (let i = 0; i < namedFile.length; i++) {
 				const res = namedFile[i];
 				if (res === undefined) {
 					continue;
 				}
 				const { path } = res;
-				FSInline.vivthFSInlinelists[path] = Buffer.from(await readFile(join(Paths.root, path)));
+				if ('path' in FSInline.vivthFSInlinelists) {
+					continue;
+				}
+				FSInline.vivthFSInlinelists[path] = Buffer.from(
+					removeVivthDevCodeBlock(await readFile(join(Paths.root, path), { encoding: 'utf-8' }))
+				);
+			}
+			const {
+				result: { named: namedDir },
+			} = resultMatchingDir;
+			for (let i = 0; i < namedDir.length; i++) {
+				const res = namedDir[i];
+				if (res === undefined) {
+					continue;
+				}
+				let { path, rule } = res;
+				rule = rule.trim();
+				const results = await FSInlineAnalyzer.#dir(join(Paths.root, path), hydrateRegex(rule));
+				for (let j = 0; j < results.length; j++) {
+					const res = results[j];
+					if (res === undefined) {
+						continue;
+					}
+					const { path, buffer } = res;
+					if (path in FSInline.vivthFSInlinelists) {
+						continue;
+					}
+					FSInline.vivthFSInlinelists[path] = buffer;
+				}
 			}
 			const {
 				result: { named: namedWorker },
@@ -118,12 +148,12 @@ export class FSInlineAnalyzer {
 				}
 				const { path } = res;
 				const fullPath = join(Paths.root, path);
-				const content = await readFile(fullPath, { encoding: 'utf-8' });
+				const content = removeVivthDevCodeBlock(await readFile(fullPath, { encoding: 'utf-8' }));
 				const [contentBundled, errorBundled] = await EsBundler(
 					{
 						content,
 						// @ts-expect-error
-						extension: extname(path),
+						extension: extname(fullPath),
 						root: dirname(fullPath),
 					},
 					{
@@ -143,29 +173,6 @@ export class FSInlineAnalyzer {
 				}
 				FSInline.vivthFSInlinelists[path] = Buffer.from(trueContent);
 			}
-			const {
-				result: { named: namedDir },
-			} = resultMatchingDir;
-			for (let i = 0; i < namedDir.length; i++) {
-				const res = namedDir[i];
-				if (res === undefined) {
-					continue;
-				}
-				let { path, rule } = res;
-				rule = rule.trim();
-				const results = await FSInlineAnalyzer.#dir(join(Paths.root, path), hydrateRegex(rule));
-				for (let j = 0; j < results.length; j++) {
-					const res = results[j];
-					if (res === undefined) {
-						continue;
-					}
-					const { path, buffer } = res;
-					if (path in FSInline.vivthFSInlinelists) {
-						continue;
-					}
-					FSInline.vivthFSInlinelists[path] = buffer;
-				}
-			}
 			return content.replace(
 				/static\s*vivthFSInlinelists(?:;|)/,
 				`static vivthFSInlinelists=${JSON.stringify(FSInline.vivthFSInlinelists)}`
@@ -208,7 +215,9 @@ export class FSInlineAnalyzer {
 				if (entry.isFile() && ruleForFileFullPath.test(fullPath)) {
 					result.push({
 						path: relativePath,
-						buffer: Buffer.from(await readFile(fullPath)),
+						buffer: Buffer.from(
+							removeVivthDevCodeBlock(await readFile(fullPath, { encoding: 'utf-8' }))
+						),
 					});
 				}
 			}

package/src/bundler/adds/ToBundledJSPlugin.mjs

@@ -1,17 +1,38 @@
 // @ts-check
 
 import { basename, extname } from 'node:path';
-import { readFile, exists } from 'node:fs/promises';
+import { readFile } from 'node:fs/promises';
+
 import { CreateESPlugin } from '../CreateESPlugin.mjs';
+import { GetNamedImportAlias } from '../../function/GetNamedImportAlias.mjs';
+import { FileSafe } from '../../class/FileSafe.mjs';
+
+/**
+ * @param {string} originalContent_
+ * @returns {string}
+ */
+export const removeVivthDevCodeBlock = (originalContent_) => {
+	const alias = GetNamedImportAlias(originalContent_, 'Dev', 'vivth');
+	if (!alias) {
+		return originalContent_;
+	}
+	const regex = new RegExp(
+		`(\\s*${alias}.vivthDevCodeBlock\\s*\\([\\s\\S]*?,\\s*['"]vivthDevCodeBlock['"]\\s*\\)(?:\\;|,|))`,
+		'g'
+	);
+	return originalContent_.replace(regex, '');
+};
 
 /**
  * @description
  * - generate `esbuild.Plugin` for changing dev time file into runtime file;
- * - on using esbuild with this plugin, it will replace any module that have similiar file name but ended with Bundled(before extname);
+ * - on using esbuild with this plugin, it will:
+ * >- replace any module that have similiar file name but ended with Bundled(before extname);
  * >- works on `.mts`|`.ts`|`.mjs`|`.cjs`|`.js`;
- * >- `anyFileName.mjs` -> seek for and use `anyFileNameBundled.mjs`, if not found use `anyFileName.mjs`;
+ * >- `${fileName}.mjs` -> seek for and use `${fileName}Bundled.mjs`, if not found use `${fileName}.mjs`;
+ * >- removes `Dev.vivthDevCodeBlock` code block;
  * @param {string} includedInPath
- * - is generalized, you can freely uses forward or backward slash;
+ * - is generalized path, you can freely uses forward or backward slash;
  * @returns {ReturnType<CreateESPlugin>}
  * @example
  * import { ToBundledJSPlugin } from 'vivth';
@@ -39,38 +60,31 @@ export function ToBundledJSPlugin(includedInPath) {
 					loader = 'js';
 					break;
 			}
-			const originalContent = (await readFile(filePath)).toString('utf-8');
-			if (loader === undefined) {
-				return {
-					contents: originalContent,
-					loader,
-				};
-			}
-			if (filePath.endsWith(`Bundled${fileExt}`)) {
-				return {
-					contents: originalContent,
-					loader,
-				};
+			/**
+			 * @type {ReturnType<Parameters<import('esbuild').PluginBuild["onLoad"]>[1]>}
+			 */
+			const ret = { loader };
+			if (loader === undefined || filePath.endsWith(`Bundled${fileExt}`)) {
+				const originalContent = (await readFile(filePath)).toString('utf-8');
+				ret.contents = removeVivthDevCodeBlock(originalContent);
+				return ret;
 			}
 			const originalBaseName = basename(filePath);
 			const originalFileName = originalBaseName.replace(fileExt, '');
 			const realRef = `${originalFileName}Bundled`;
-			const runtimeFile = filePath.replace(
+			const bundledFile = filePath.replace(
 				new RegExp(`${originalBaseName}\$`.replace('.', '\\.'), ''),
 				`${realRef}${fileExt}`
 			);
-			const isExist = await exists(runtimeFile);
-			if (isExist === false) {
-				return {
-					contents: originalContent,
-					loader,
-				};
+			const [, error] = await FileSafe.exist(bundledFile);
+			if (error) {
+				const originalContent = (await readFile(filePath)).toString('utf-8');
+				ret.contents = removeVivthDevCodeBlock(originalContent);
+				return ret;
 			}
-			const contents = (await readFile(runtimeFile)).toString('utf-8');
-			return {
-				contents,
-				loader,
-			};
+			const originalContent = (await readFile(bundledFile)).toString('utf-8');
+			ret.contents = removeVivthDevCodeBlock(originalContent);
+			return ret;
 		});
 	});
 }

package/src/bundler/adds/pluginVivthBundle.mjs

@@ -2,4 +2,6 @@
 
 import { ToBundledJSPlugin } from './ToBundledJSPlugin.mjs';
 
-export const pluginVivthBundle = ToBundledJSPlugin('/vivth/src/');
+const path = '/vivth/src/';
+
+export const pluginVivthBundle = ToBundledJSPlugin(path);

package/src/class/EventSignal.mjs

@@ -135,17 +135,20 @@ export class EventSignal {
 		 * @description
 		 * - remove subscriber from the named `EventSignal_instance`;
 		 * @param {string} name
-		 * @param {import('./Effect.mjs').Effect} effect
+		 * @param {import('./Effect.mjs').Effect} effectInstance
 		 * @returns {void}
 		 * @example
 		 * import { EventSignal } from 'vivth';
 		 *
 		 * EventSignal.remove.subscriber('yourEventSignalName', myEffectInstance);
 		 */
-		subscriber: (name, effect) => {
-			effect.options.removeEffect();
+		subscriber: (name, effectInstance) => {
+			/**
+			 * this part is not needed, as the effect might need to react to other signals
+			// effectInstance.options.removeEffect();
+			 */
 			EventSignal.get(name).then(({ remove }) => {
-				remove.subscriber(effect);
+				remove.subscriber(effectInstance);
 			});
 		},
 		/**
@@ -186,7 +189,7 @@ export class EventSignal {
 		 * @instance remove
 		 * @description
 		 * - remove subscriber from the `EventSignal_instance`;
-		 * @param {import('./Effect.mjs').Effect} effect
+		 * @param {import('./Effect.mjs').Effect} effectInstance
 		 * @returns {void}
 		 * @example
 		 * import { EventSignal, Effect, Console } from 'vivth';
@@ -200,10 +203,13 @@ export class EventSignal {
 		 * myEventSignal.dispatch.value = 'hey';
 		 * eventSignal_instance.remove.subscriber(myEffectInstance);
 		 */
-		subscriber: (effect) => {
-			effect.options.removeEffect();
-			this.dispatch.remove.subscriber(effect);
-			this.listen.remove.subscriber(effect);
+		subscriber: (effectInstance) => {
+			/**
+			 * this part is not needed, as the effect might need to react to other signals
+			// effectInstance.options.removeEffect();
+			 */
+			this.dispatch.remove.subscriber(effectInstance);
+			this.listen.remove.subscriber(effectInstance);
 		},
 		/**
 		 * @instance remove