@fastkit/plugboy 0.3.0 → 1.0.0-next.0

package/dist/workspace-BqcryYAT.mjs

@@ -0,0 +1,1391 @@
+import path from "node:path";
+import fs from "node:fs";
+import { fileURLToPath } from "node:url";
+import { glob } from "glob";
+import { bundleRequire } from "bundle-require";
+import fs$1 from "node:fs/promises";
+import { build } from "tsdown";
+import { execa } from "execa";
+import { parse } from "acorn";
+import sortPackageJson from "sort-package-json";
+import * as prompts from "@inquirer/prompts";
+
+//#region src/types/hook.ts
+function createHooksDefaults() {
+	return {
+		setupWorkspace: [],
+		createWorkspace: [],
+		preparePackageJSON: []
+	};
+}
+
+//#endregion
+//#region src/types/dts.ts
+function normalizeDTSPreserveTypeTarget(target) {
+	const { from, typeName } = target;
+	return {
+		from: typeof from === "string" ? new RegExp(`${from}`, "g") : from,
+		typeName
+	};
+}
+function normalizeDTSPreserveTypeSettings(settings) {
+	return {
+		...settings,
+		targets: settings.targets.map(normalizeDTSPreserveTypeTarget)
+	};
+}
+function normalizeDTSSettings(settings) {
+	const { inline = false, compiler = "tsc", ignoreCompilerErrors = false, preserveType = [], normalizers = [] } = settings || {};
+	return {
+		inline,
+		compiler,
+		ignoreCompilerErrors,
+		preserveType: preserveType.map(normalizeDTSPreserveTypeSettings),
+		normalizers
+	};
+}
+function mergeDTSSettingsList(...settingsList) {
+	const merged = {};
+	settingsList.forEach((settings) => {
+		if (!settings) return;
+		const { inline, preserveType, normalizers } = settings;
+		if (inline !== void 0) merged.inline = inline;
+		if (preserveType) {
+			merged.preserveType = merged.preserveType || [];
+			merged.preserveType.push(...preserveType);
+		}
+		if (normalizers) {
+			merged.normalizers = merged.normalizers || [];
+			merged.normalizers.push(...normalizers);
+		}
+	});
+	return normalizeDTSSettings(merged);
+}
+
+//#endregion
+//#region src/types/css.ts
+function resolveOptimizeCSSOptions(options) {
+	const resolved = {};
+	const { layer = true, media = true, combineRules, cssnano = true } = options;
+	if (layer !== false) resolved.layer = layer === true ? {} : layer;
+	if (media !== false) resolved.media = media === true ? {} : media;
+	if (combineRules) resolved.combineRules = combineRules;
+	if (cssnano !== false) resolved.cssnano = cssnano === true ? { preset: ["default", { normalizeWhitespace: false }] } : cssnano;
+	return resolved;
+}
+
+//#endregion
+//#region src/types/workspace.ts
+const WORKSPACE_REQUIRED_FIELDS = ["name", "version"];
+const TSDOWN_SYNC_OPTIONS = [
+	"define",
+	"noExternal",
+	"external",
+	"skipNodeModulesBundle",
+	"onSuccess",
+	"copy"
+];
+
+//#endregion
+//#region src/types/project.ts
+const PROJECT_REQUIRED_FIELDS = ["name"];
+
+//#endregion
+//#region src/utils/general.ts
+function isPromise(obj) {
+	return !!obj && (typeof obj === "object" || typeof obj === "function") && typeof obj.then === "function";
+}
+async function resolveListable(raw) {
+	const result = [];
+	const list = Array.isArray(raw) ? raw : [raw];
+	for (let row of list) {
+		if (isPromise(row)) row = await row;
+		if (!row) continue;
+		if (Array.isArray(row)) {
+			result.push(...await resolveListable(row));
+			continue;
+		}
+		result.push(row);
+	}
+	return result;
+}
+
+//#endregion
+//#region src/utils/tsdown.ts
+const _stringChunkToObject = (source) => {
+	if (typeof source === "object") return source;
+	return {
+		js: source,
+		dts: source,
+		css: source
+	};
+};
+const _resolveChunkAddonToObject = (source, ...args) => {
+	return _stringChunkToObject(typeof source === "function" ? source(...args) || {} : source);
+};
+const _mergeChunkAddonObjects = (base, override, position = "after") => {
+	const result = { ..._stringChunkToObject(base) };
+	for (const [_key, value] of Object.entries(_stringChunkToObject(override))) {
+		if (!value) continue;
+		const key = _key;
+		const baseValue = result[key];
+		const chunks = [value];
+		if (baseValue) if (position === "before") chunks.push(baseValue);
+		else chunks.unshift(baseValue);
+		result[key] = chunks.join("\n\n");
+	}
+	return result;
+};
+function mergeChunkAddons(base, override, position) {
+	if (!override) return base;
+	if (!base) return override;
+	if (typeof base === "function" || typeof override === "function") return (...args) => {
+		return _mergeChunkAddonObjects(_resolveChunkAddonToObject(base, ...args), _resolveChunkAddonToObject(override, ...args), position);
+	};
+	return _mergeChunkAddonObjects(base, override);
+}
+function isExternal(externalOption, id, parentId, isResolved) {
+	if (Array.isArray(externalOption)) return externalOption.some((e) => isExternal(e, id, parentId, isResolved));
+	if (typeof externalOption === "string") return id === externalOption;
+	if (externalOption instanceof RegExp) return externalOption.test(id);
+	if (typeof externalOption === "function") return externalOption(id, parentId, isResolved);
+	return false;
+}
+function mergeExternals(base, override) {
+	if (!override) return base;
+	if (!base) return override;
+	const externals = [base, override];
+	return (id, parentId, isResolved) => {
+		return externals.some((external) => {
+			return isExternal(external, id, parentId, isResolved);
+		});
+	};
+}
+function isNoExternal(noExternalOption, id, importer) {
+	if (Array.isArray(noExternalOption)) return noExternalOption.some((e) => isNoExternal(e, id, importer));
+	if (typeof noExternalOption === "string") return id === noExternalOption;
+	if (noExternalOption instanceof RegExp) return noExternalOption.test(id);
+	if (typeof noExternalOption === "function") return noExternalOption(id, importer);
+	return false;
+}
+function mergeNoExternals(base, override) {
+	if (!override) return base;
+	if (!base) return override;
+	if (typeof base !== "function" && typeof override !== "function") {
+		const _base = Array.isArray(base) ? base.slice() : [base];
+		const _override = Array.isArray(override) ? override.slice() : [override];
+		return [..._base, ..._override];
+	}
+	const noExternals = [base, override];
+	return (id, importer) => {
+		return noExternals.some((spec) => {
+			return isNoExternal(spec, id, importer);
+		});
+	};
+}
+
+//#endregion
+//#region src/utils/exit-hook.ts
+const EXIT_SIGNALS = [
+	"SIGINT",
+	"SIGTERM",
+	"SIGHUP"
+];
+const _callbacks = [];
+function exitHook(cb) {
+	_callbacks.push(cb);
+	const off = () => {
+		const index = _callbacks.indexOf(cb);
+		if (index !== -1) _callbacks.splice(index, 1);
+	};
+	return off;
+}
+for (const signal of EXIT_SIGNALS) process.on(signal, async () => {
+	const callbacks = _callbacks.slice();
+	_callbacks.length = 0;
+	try {
+		await Promise.all(callbacks.map((cb) => cb()));
+		process.exit(0);
+	} catch (_err) {
+		console.error(_err);
+		process.exit(1);
+	}
+});
+
+//#endregion
+//#region src/utils/file.ts
+function getFilename(importMetaURL) {
+	return fileURLToPath(importMetaURL);
+}
+function getDirname(importMetaURL) {
+	return path.dirname(getFilename(importMetaURL));
+}
+const FILE_NOT_FOUND_EXCEPTION_CODES = ["ENOTDIR", "ENOENT"];
+function isFileNotFoundException(source) {
+	return !!source && typeof source === "object" && FILE_NOT_FOUND_EXCEPTION_CODES.includes(source.code);
+}
+async function pathExists(target, type) {
+	try {
+		const stats = await fs.promises.stat(target);
+		if (!type) return true;
+		return type === "file" ? stats.isFile() : stats.isDirectory();
+	} catch (err) {
+		if (isFileNotFoundException(err)) return false;
+		throw err;
+	}
+}
+function normalizeFileMatcher(matcher) {
+	if (typeof matcher === "function") return matcher;
+	if (typeof matcher === "string") return (file) => file.name.includes(matcher);
+	return (file) => matcher.test(file.name);
+}
+async function findFile(dir, matcher, recursive = true) {
+	const files = await fs.promises.readdir(dir, { withFileTypes: true });
+	const _matcher = normalizeFileMatcher(matcher);
+	const dirs = recursive ? [] : void 0;
+	for (const file of files) {
+		if (dirs && file.isDirectory()) {
+			dirs.push(file);
+			continue;
+		}
+		if (await _matcher(file, dir)) return path.join(dir, file.name);
+	}
+	if (dirs) for (const subDir of dirs) {
+		const hit = await findFile(path.join(dir, subDir.name), _matcher, recursive);
+		if (hit) return hit;
+	}
+}
+const FIND_CONFIG_OR_RE = /\(.+?\)/g;
+function parseFindConfigFileName(source) {
+	const matches = source.match(FIND_CONFIG_OR_RE);
+	if (!matches) return [source];
+	return matches.map((matched) => {
+		return matched.slice(1, matched.length - 1).split("|").map((part) => {
+			return parseFindConfigFileName(source.replace(matched, part));
+		}).flat();
+	}).flat();
+}
+function parseRawFindConfigFileName(source) {
+	return Array.isArray(source) ? source.map(parseFindConfigFileName).flat() : parseFindConfigFileName(source);
+}
+async function findConfig(fileNameOrSettings, dir = process.cwd(), currentDepth = 0) {
+	const settings = typeof fileNameOrSettings === "object" && !Array.isArray(fileNameOrSettings) ? fileNameOrSettings : { fileName: fileNameOrSettings };
+	const { fileName, test, depth = 10, allowMissing } = settings;
+	const fileNames = parseRawFindConfigFileName(fileName);
+	if (depth && currentDepth === depth) {
+		if (allowMissing) return null;
+		throw new Error(`Failed to retrieve the "${fileName}" file because the maximum depth was reached.`);
+	}
+	const next = (err) => {
+		const nextDir = path.dirname(dir);
+		if (nextDir !== dir) return findConfig(settings, nextDir, currentDepth + 1);
+		if (allowMissing) return null;
+		throw err || /* @__PURE__ */ new Error(`missing config "${fileName}"`);
+	};
+	const result = await (async () => {
+		for (const fileName of fileNames) try {
+			const _path = path.join(dir, fileName);
+			const _result = {
+				fileName,
+				dir,
+				path: _path,
+				code: await fs.promises.readFile(_path, "utf-8")
+			};
+			if (!test || test(_result)) return _result;
+		} catch (err) {
+			if (!isFileNotFoundException(err)) throw err;
+		}
+	})();
+	if (!result) return next();
+	return result;
+}
+function _rmrf(_path) {
+	return fs.promises.rm(_path, {
+		recursive: true,
+		force: true
+	}).catch((err) => {
+		if (isFileNotFoundException(err)) return;
+		throw err;
+	});
+}
+async function rmrf(...paths) {
+	await Promise.all(paths.map((_path) => _rmrf(_path)));
+}
+function copyDirSync(srcDir, destDir) {
+	if (!fs.existsSync(srcDir)) return;
+	fs.mkdirSync(destDir, { recursive: true });
+	for (const file of fs.readdirSync(srcDir)) {
+		const srcFile = path.resolve(srcDir, file);
+		if (srcFile === destDir) continue;
+		const destFile = path.resolve(destDir, file);
+		if (fs.statSync(srcFile).isDirectory()) copyDirSync(srcFile, destFile);
+		else fs.copyFileSync(srcFile, destFile);
+	}
+}
+async function writeFileAtomic(filePath, content) {
+	const tempFile = `${filePath}.${process.pid}.tmp`;
+	const cleanup = () => {
+		return fs.promises.unlink(tempFile).catch(() => {});
+	};
+	const off = exitHook(cleanup);
+	try {
+		await fs.promises.writeFile(tempFile, content);
+		await fs.promises.rename(tempFile, filePath);
+		off();
+	} catch (error) {
+		off();
+		await cleanup();
+		throw error;
+	}
+}
+
+//#endregion
+//#region src/utils/expose.ts
+function resolveRawExposeEntriesSettings(rawSettings) {
+	return typeof rawSettings === "string" ? { dir: rawSettings } : rawSettings;
+}
+const TRIM_PATH_RE = /(^\.?\/|\/$)/g;
+const TRIM_EXT_RE = /\.ts$/;
+async function exposeEntries(rawSettings) {
+	const { dir: _dir, prefix: _prefix } = resolveRawExposeEntriesSettings(rawSettings);
+	const dir = path.resolve(_dir);
+	const prefix = _prefix ? _prefix.replace(TRIM_PATH_RE, "") : "";
+	const files = await glob(path.join(dir, "**/*.ts"));
+	const entries = {};
+	for (const file of files) {
+		const id = (prefix + file.replace(dir, "")).replace(TRIM_EXT_RE, "").replace(TRIM_PATH_RE, "");
+		entries[id] = { src: file };
+	}
+	return entries;
+}
+
+//#endregion
+//#region src/constants.ts
+const PROJECT_CONFIG_BASENAME = "plugboy.project";
+const WORKSPACE_CONFIG_BASENAME = "plugboy.workspace";
+const PACKAGE_JSON_FILENAME = "package.json";
+const WORKSPACE_SPEC_PREFIX = "workspace:";
+const SEARCH_BUNDLE_EXTENSIONS_MATCH = "(ts|mjs|js|json)";
+
+//#endregion
+//#region src/utils/project.ts
+function isProjectPackageJson(json) {
+	return !!json.private && PROJECT_REQUIRED_FIELDS.every((filed) => !!json[filed]);
+}
+async function resolveUserProjectConfig(userConfig) {
+	const { workspacesDir = "packages", scripts = [], peerDependencies = {}, tsconfig, readme = (json) => `# ${json.name}\n`, plugins, optimizeCSS = true, hooks } = userConfig;
+	return {
+		workspacesDir,
+		scripts: Array.isArray(scripts) ? scripts : [{
+			name: "",
+			scripts
+		}],
+		peerDependencies,
+		tsconfig,
+		readme,
+		plugins: await resolveUserPluginOption(plugins),
+		optimizeCSS: optimizeCSS === true ? {} : optimizeCSS,
+		hooks
+	};
+}
+function defineProjectConfig(config) {
+	return resolveUserProjectConfig(config);
+}
+async function loadProjectConfig(searchDir, depth) {
+	const hit = await findConfig({
+		fileName: `${PROJECT_CONFIG_BASENAME}.${SEARCH_BUNDLE_EXTENSIONS_MATCH}`,
+		depth,
+		allowMissing: true
+	}, searchDir);
+	return resolveUserProjectConfig(await (hit ? (await bundleRequire({ filepath: hit.path })).mod.default : {}));
+}
+
+//#endregion
+//#region src/utils/plugin.ts
+async function resolveUserPluginOption(pluginOption) {
+	if (!pluginOption) return [];
+	const awaited = await pluginOption;
+	if (!awaited) return [];
+	if (Array.isArray(pluginOption)) return (await Promise.all(pluginOption.map((o) => resolveUserPluginOption(o)).flat())).flat();
+	return [awaited];
+}
+function definePlugin(options) {
+	return options;
+}
+async function extractProjectPlugins(searchDir) {
+	const config = await loadProjectConfig(searchDir);
+	return config ? config.plugins : [];
+}
+async function findProjectPlugin(pluginName, searchDir) {
+	return (await extractProjectPlugins(searchDir)).find((plugin) => plugin.name === pluginName);
+}
+
+//#endregion
+//#region src/utils/workspace.ts
+function isWorkspacePackageJson(json) {
+	return !json.private && WORKSPACE_REQUIRED_FIELDS.every((filed) => !!json[filed]);
+}
+function resolveRawWorkspaceEntry(entry) {
+	const { src, css } = typeof entry === "string" ? { src: entry } : entry;
+	return {
+		src,
+		css: css || src.endsWith(".css") || src.endsWith(".scss")
+	};
+}
+function resolveRawWorkspaceEntries(entries) {
+	if (!entries) return {};
+	return Object.fromEntries(Object.entries(entries).map(([name, raw]) => [name, resolveRawWorkspaceEntry(raw)]));
+}
+async function resolveUserWorkspaceConfig(userConfig) {
+	const { ignoreProjectConfig = false, entries, plugins, optimizeCSS = true, hooks } = userConfig;
+	return {
+		...userConfig,
+		ignoreProjectConfig,
+		entries: resolveRawWorkspaceEntries(entries),
+		plugins: await resolveUserPluginOption(plugins),
+		optimizeCSS: optimizeCSS === true ? {} : optimizeCSS,
+		hooks
+	};
+}
+function defineWorkspaceConfig(config) {
+	return resolveUserWorkspaceConfig(config);
+}
+async function loadWorkspaceConfig(searchDir, depth) {
+	const hit = await findConfig({
+		fileName: `${WORKSPACE_CONFIG_BASENAME}.${SEARCH_BUNDLE_EXTENSIONS_MATCH}`,
+		depth,
+		allowMissing: true
+	}, searchDir);
+	return resolveUserWorkspaceConfig(await (hit ? (await bundleRequire({ filepath: hit.path })).mod.default : {}));
+}
+
+//#endregion
+//#region src/utils/hook.ts
+async function resolveUserHooks(...userHooks) {
+	const hooks = createHooksDefaults();
+	if (!userHooks) return hooks;
+	for (const userHook of userHooks) {
+		if (!userHook) continue;
+		for (const [hookName, _hooks] of Object.entries(userHook)) if (hooks) hooks[hookName].push(...await resolveListable(_hooks));
+	}
+	return hooks;
+}
+function buildHooks(resolvedHooks) {
+	const hooks = {};
+	Object.entries(resolvedHooks).forEach(([hookName, fns]) => {
+		hooks[hookName] = async (...args) => {
+			const results = [];
+			for (const fn of fns) results.push(await fn(...args));
+			return results;
+		};
+	});
+	return hooks;
+}
+
+//#endregion
+//#region src/path.ts
+var Path = class Path {
+	_value;
+	_stats;
+	get value() {
+		return this._value;
+	}
+	set value(value) {
+		if (path.resolve(value) === this._value) return;
+		this._value = path.resolve(value);
+		delete this._stats;
+	}
+	get dirname() {
+		return path.dirname(this.value);
+	}
+	get basename() {
+		return path.basename(this.value);
+	}
+	get extname() {
+		return path.extname(this.value);
+	}
+	get stats() {
+		let { _stats } = this;
+		if (!_stats) {
+			_stats = fs.statSync(this.value);
+			this._stats = _stats;
+		}
+		return _stats;
+	}
+	get isDirectory() {
+		return this.stats.isDirectory;
+	}
+	get isFile() {
+		return this.stats.isFile;
+	}
+	constructor(value) {
+		this._value = path.resolve(value);
+	}
+	toString() {
+		return this.value;
+	}
+	valueOf() {
+		return this.value;
+	}
+	toJSON() {
+		return this.value;
+	}
+	relative(to) {
+		return new Path(path.relative(this.value, to));
+	}
+	join(...paths) {
+		return new Path(path.join(this.value, ...paths));
+	}
+	resolve(...paths) {
+		return new Path(path.resolve(this.value, ...paths));
+	}
+	_join(...paths) {
+		const _paths = paths.filter((_path) => !!_path);
+		return _paths.length ? path.join(this.value, ..._paths) : this.value;
+	}
+	async readdir(...paths) {
+		const dir = this._join(...paths);
+		return (await fs.promises.readdir(dir)).map((file) => new Path(path.join(dir, file)));
+	}
+	readFile(pathAppend, defaults) {
+		return new Promise((resolve, reject) => {
+			fs.readFile(this._join(pathAppend), "utf-8", (err, data) => {
+				if (err) {
+					if (defaults !== void 0 && isFileNotFoundException(err)) return resolve(defaults);
+					return reject(err);
+				}
+				resolve(data);
+			});
+		});
+	}
+	async readJSON(pathAppend, defaults) {
+		try {
+			const file = await this.readFile(pathAppend);
+			return JSON.parse(file);
+		} catch (err) {
+			if (defaults === void 0) throw err;
+			return defaults;
+		}
+	}
+};
+
+//#endregion
+//#region src/package.ts
+async function getProjectPackageJson(searchDir, allowMissing) {
+	const hit = await findConfig({
+		fileName: PACKAGE_JSON_FILENAME,
+		allowMissing,
+		test: (result) => isProjectPackageJson(JSON.parse(result.code))
+	}, searchDir);
+	if (!hit) {
+		if (allowMissing) return null;
+		throw new Error("missing project package.");
+	}
+	return {
+		dir: new Path(hit.dir),
+		json: JSON.parse(hit.code)
+	};
+}
+async function getWorkspacePackageJson(searchDir, allowMissing) {
+	const hit = await findConfig({
+		fileName: PACKAGE_JSON_FILENAME,
+		allowMissing,
+		test: (result) => isWorkspacePackageJson(JSON.parse(result.code))
+	}, searchDir);
+	if (!hit) {
+		if (allowMissing) return null;
+		throw new Error("missing workspace package.");
+	}
+	return {
+		dir: new Path(hit.dir),
+		json: JSON.parse(hit.code)
+	};
+}
+async function findWorkspacePackages(dir) {
+	const results = [];
+	const searchDir = path.resolve(dir);
+	const dirs = await fs$1.readdir(searchDir);
+	(await Promise.all(dirs.map((dirName) => getWorkspacePackageJson(path.join(searchDir, dirName), true)))).forEach((pkg) => {
+		pkg && results.push(pkg);
+	});
+	return results;
+}
+
+//#endregion
+//#region src/workspace/dts.ts
+async function runTsc(compiler, opts = {}, ignoreErrors) {
+	const { cwd = process.cwd(), outDir = path.join(cwd, "dist/dts") } = opts;
+	try {
+		await execa(compiler, [
+			"--declaration true",
+			"--skipLibCheck",
+			"--noEmit false",
+			"--emitDeclarationOnly",
+			`--outDir ${outDir}`
+		], {
+			cwd,
+			shell: true,
+			stdio: "inherit"
+		});
+	} catch (e) {
+		if (!ignoreErrors) throw e;
+		console.log(`Note: ${compiler} reported errors, but continuing with generated files...`);
+	}
+}
+/**
+* Emit DTS (declaration files)
+*/
+async function emitDTS(opts) {
+	const { compiler = "tsc", ignoreCompilerErrors = false, workspace, ...baseOpts } = opts;
+	if (typeof compiler === "function") await compiler({
+		...baseOpts,
+		workspace
+	});
+	else await runTsc(compiler, { ...baseOpts }, ignoreCompilerErrors);
+}
+
+//#endregion
+//#region src/env/constants.ts
+const PLUGBOY_VAR_ENVS_FOR_BUNDLE = {
+	__PLUGBOY_STUB__: "false",
+	__PLUGBOY_DEV__: `#(typeof process !== 'undefined' && process.env?.NODE_ENV === 'development') || (typeof import.meta !== 'undefined' && import.meta.env?.DEV === true)`
+};
+const PLUGBOY_VAR_ENVS_FOR_STUB = {
+	__PLUGBOY_STUB__: "true",
+	__PLUGBOY_DEV__: "true"
+};
+
+//#endregion
+//#region src/env/utils.ts
+function applyPlugboyEnvs(config) {
+	const DEFINE_VAR_INJECTS = Object.fromEntries(Object.entries(PLUGBOY_VAR_ENVS_FOR_BUNDLE).map(([envName, value]) => {
+		return [envName, value.startsWith("#") ? `$$${envName}` : value];
+	}));
+	config.define = {
+		...config.define,
+		...DEFINE_VAR_INJECTS
+	};
+}
+function getPlugboyEnvCodeForStub() {
+	return Object.entries(PLUGBOY_VAR_ENVS_FOR_STUB).map(([envName, variable]) => `globalThis.${envName} = ${variable};`).join("\n");
+}
+
+//#endregion
+//#region src/env/plugin.ts
+function findAfterImports(code) {
+	const ast = parse(code, {
+		sourceType: "module",
+		ecmaVersion: "latest"
+	});
+	let end = 0;
+	for (const node of ast.body) {
+		if (node.type === "ImportDeclaration" || node.type === "ExportNamedDeclaration" || node.type === "ExportAllDeclaration" || node.type === "ExportDefaultDeclaration") {
+			end = Math.max(end, node.end);
+			continue;
+		}
+		break;
+	}
+	return end;
+}
+const _replacements = [];
+Object.entries(PLUGBOY_VAR_ENVS_FOR_BUNDLE).forEach(([envName, value]) => {
+	if (value.startsWith("#")) _replacements.push([`$$${envName}`, value.substring(1)]);
+});
+function WorkspaceEnvPlugin(_workspace) {
+	return {
+		name: "plugboy-workspace-env",
+		async renderChunk(code, _chunk) {
+			const injects = _replacements.filter(([envName]) => code.includes(envName));
+			if (injects.length) {
+				const MagicString = (await import("magic-string")).default;
+				const ms = new MagicString(code);
+				const insertPos = findAfterImports(code);
+				const injectCode = injects.map(([eventName, value]) => `const ${eventName} = ${value};`).join("\n");
+				ms.appendLeft(insertPos, `\n${injectCode}`);
+				return {
+					code: ms.toString(),
+					map: ms.generateMap({ hires: true })
+				};
+			}
+		}
+	};
+}
+
+//#endregion
+//#region src/workspace/builder.ts
+const SHEBANG_MATCH_RE = /^(#!.+?)\n/;
+var Builder = class {
+	workspace;
+	_tsdownOptions;
+	get entry() {
+		return this.workspace.entry;
+	}
+	get dts() {
+		return this.workspace.dts;
+	}
+	constructor(workspace) {
+		this.workspace = workspace;
+	}
+	async tsdownOptions(overrides) {
+		let { _tsdownOptions } = this;
+		if (_tsdownOptions) return _tsdownOptions;
+		const { entry, dts } = this;
+		_tsdownOptions = {
+			dts: dts.inline || typeof dts.compiler === "function" ? false : dts.compiler === "vue-tsc" ? { vue: true } : true,
+			treeshake: true,
+			plugins: this.workspace.plugins,
+			entry,
+			sourcemap: true,
+			clean: true,
+			...overrides
+		};
+		for (const opt of TSDOWN_SYNC_OPTIONS) _tsdownOptions[opt] = this.workspace.config[opt];
+		applyPlugboyEnvs(_tsdownOptions);
+		_tsdownOptions.external = mergeExternals(_tsdownOptions.external, [/^(@fastkit\/)?plugboy(?!\/runtime-utils)/, ...this.workspace.dependencies]);
+		this._tsdownOptions = _tsdownOptions;
+		return _tsdownOptions;
+	}
+	async _stubLinkJS(from, to) {
+		const fromParsed = path.parse(from);
+		const fromDir = fromParsed.dir;
+		const toParsed = path.parse(to);
+		const toRelativeDir = path.relative(fromDir, toParsed.dir);
+		const location = path.join(toRelativeDir, toParsed.base);
+		const shebang = (await fs$1.readFile(to, "utf-8")).match(SHEBANG_MATCH_RE)?.[1];
+		const disableChecks = "/* eslint-disable */\n// @ts-nocheck\n";
+		const code = `${disableChecks}${getPlugboyEnvCodeForStub()}\nexport * from '${location}';`;
+		const dtsPath = path.join(fromDir, `${fromParsed.name}.d.mts`);
+		const dtsCode = `${disableChecks}export * from '${location.replace(/\.ts$/, "")}';`;
+		const srcFromDir = path.dirname(from);
+		const dtsDir = path.dirname(dtsPath);
+		await Promise.all([srcFromDir, dtsDir].map((dir) => fs$1.mkdir(dir, { recursive: true })));
+		await Promise.all([fs$1.writeFile(from, `${shebang ? `${shebang}\n` : ""}${code}`), fs$1.writeFile(dtsPath, dtsCode)]);
+	}
+	async _stubLinkCSS(from) {
+		await fs$1.writeFile(from, `/* noop */`);
+	}
+	async copyPublicDir() {
+		const publicDir = this.workspace.dir.join("public").value;
+		await copyDirSync(publicDir, this.workspace.dirs.dist.value);
+	}
+	async stub() {
+		const links = this.workspace.getStubLinks();
+		await this.copyPublicDir();
+		await Promise.all(links.map((link) => {
+			if (link.type === "js") return this._stubLinkJS(link.from, link.to);
+			if (link.type === "css") return this._stubLinkCSS(link.from);
+			throw new Error(`non supported type`);
+		}));
+		await fs$1.writeFile(this.workspace.dirs.dist.join(".stub").value, "", "utf-8");
+	}
+	normalizeDTSBySettings(dts, settings) {
+		const { targets, pkg } = settings;
+		const packageIsOwn = this.workspace.json.name === pkg;
+		const pkgImports = (() => {
+			if (!pkg || packageIsOwn) return;
+			const importRe = new RegExp(`import {([^\\{\\}]+)} from '${pkg}'`);
+			const importMatched = dts.match(importRe);
+			const imports = importMatched && importMatched[1];
+			if (!imports) return;
+			return {
+				pkg,
+				importRe,
+				imports
+			};
+		})();
+		const hitTypeNames = [];
+		targets.forEach(({ from, typeName }) => {
+			if (dts.match(from)) {
+				hitTypeNames.push(typeName);
+				dts = dts.replace(from, typeName);
+			}
+		});
+		if (!hitTypeNames.length) return;
+		if (pkgImports) {
+			const { pkg, imports, importRe } = pkgImports;
+			const mods = imports.trim().split(",").map((row) => {
+				row = row.split(" as ")[0].trim();
+				return row;
+			});
+			const appends = [];
+			hitTypeNames.forEach((typeName) => {
+				if (!new RegExp(`(^|\n)import { ${typeName} } from '${pkg}'`).test(dts) && !mods.includes(typeName)) appends.push(typeName);
+			});
+			if (appends.length) dts = dts.replace(importRe, `import { $1, ${appends.join(", ")} } from '${pkg}'`);
+		} else if (pkg && !packageIsOwn) {
+			const mods = [];
+			hitTypeNames.forEach((typeName) => {
+				if (!dts.includes(`export declare type ${typeName} = `)) mods.push(typeName);
+			});
+			if (mods.length) dts = `import { ${mods.join(", ")} } from '${pkg}';\n${dts}`;
+		}
+		return dts;
+	}
+	async normalizeDTSFile(filePath) {
+		const dts = await fs$1.readFile(filePath, "utf-8");
+		const { preserveType, normalizers } = this.dts;
+		let normalized = dts;
+		let processed = false;
+		for (const settings of preserveType) {
+			const _normalized = this.normalizeDTSBySettings(normalized, settings);
+			if (_normalized) {
+				processed = true;
+				normalized = _normalized;
+			}
+		}
+		for (const normalizer of normalizers) {
+			const _normalized = await normalizer(normalized, this);
+			if (_normalized && normalized !== _normalized) {
+				processed = true;
+				normalized = _normalized;
+			}
+		}
+		if (!processed) return;
+		await fs$1.writeFile(filePath, normalized, "utf-8");
+	}
+	async normalizeDTSFiles(dtsFiles = this.workspace.dtsFiles) {
+		const { preserveType } = this.dts;
+		if (!preserveType.length || !dtsFiles.length) return;
+		await Promise.all(dtsFiles.map((filePath) => this.normalizeDTSFile(filePath)));
+	}
+	async emitDTSManually() {
+		const { dir, dirs, exports } = this.workspace;
+		const cwd = dir.value;
+		const outDir = dirs.dist.join(".dts-generate").value;
+		const dtsSrcDir = path.join(outDir, "src");
+		const dtsDest = dirs.dist.join(".dts").value;
+		await emitDTS({
+			cwd,
+			outDir,
+			workspace: this.workspace,
+			compiler: this.workspace.dts.compiler,
+			ignoreCompilerErrors: this.workspace.dts.ignoreCompilerErrors
+		});
+		await fs$1.rename(dtsSrcDir, dtsDest);
+		await rmrf(outDir);
+		const objectExports = [];
+		exports.forEach(({ at }) => {
+			typeof at === "object" && objectExports.push(at);
+		});
+		await Promise.all(objectExports.map(async (at) => {
+			const typesDir = path.dirname(at.types);
+			const dtsDestDir = path.dirname(at.dtsDest);
+			const relativeDir = path.relative(typesDir, dtsDestDir);
+			const code = `export * from './${path.join(relativeDir, path.basename(at.dtsDest).replace(/\.d\.m?ts$/, ""))}';`;
+			await fs$1.writeFile(at.types, code, "utf-8");
+		}));
+		const dtsFiles = await glob(path.join(dtsDest, "**/*.{d.ts,d.mts}"));
+		await this.normalizeDTSFiles(dtsFiles);
+	}
+	async build() {
+		await build(await this.tsdownOptions());
+		if (this.dts.inline || typeof this.dts.compiler === "function") await this.emitDTSManually();
+		else await this.normalizeDTSFiles();
+	}
+};
+
+//#endregion
+//#region src/project/project.ts
+/**
+* Plugboy Project
+*
+* @remarks This instance is only created if the project consists of a mono-repo.
+*/
+var PlugboyProject = class {
+	/** Path instance of the project directory */
+	dir;
+	/** package.json */
+	json;
+	/**
+	* Project Configuration
+	* @see {@link ResolvedProjectConfig}
+	*/
+	config;
+	/** Names of all packages on which the project depends */
+	dependencies;
+	/** Directory names of all workspaces owned by the project */
+	resolvedWorkspaces;
+	/**
+	* Name of the project's package.json
+	*/
+	get name() {
+		return this.json.name;
+	}
+	/**
+	* Plug-in List
+	* @see {@link ResolvedProjectConfig.plugins}
+	*/
+	get plugins() {
+		return this.config.plugins;
+	}
+	/**
+	* List of all user hook settings
+	* @see {@link UserHooks}
+	*/
+	get hooks() {
+		const { hooks: _hooks, plugins } = this.config;
+		return [_hooks, ...plugins.map((plugin) => plugin.hooks)].filter((hook) => !!hook);
+	}
+	constructor(ctx) {
+		const { dir, json, config, resolvedWorkspaces } = ctx;
+		this.dir = dir;
+		this.json = json;
+		this.config = config;
+		const allDeps = {
+			...json.dependencies,
+			...json.devDependencies
+		};
+		this.dependencies = Object.keys(allDeps);
+		this.resolvedWorkspaces = resolvedWorkspaces;
+	}
+};
+async function getProject(searchDir, allowMissing, skipLoadConfig) {
+	const hit = await getProjectPackageJson(searchDir, allowMissing);
+	if (!hit) return null;
+	const { dir, json } = hit;
+	const resolvedWorkspaces = [];
+	const { workspaces = [] } = json;
+	if (!Array.isArray(workspaces)) throw new Error("workspaces only supports arrays.");
+	const workspaceHits = await glob(workspaces.map((workspace) => dir.join(workspace, PACKAGE_JSON_FILENAME).value));
+	for (const _hit of workspaceHits) {
+		if (!isWorkspacePackageJson(JSON.parse(await fs$1.readFile(_hit, "utf-8")))) continue;
+		resolvedWorkspaces.push(path.dirname(_hit));
+	}
+	resolvedWorkspaces.sort((a, b) => {
+		if (a < b) return -1;
+		if (a > b) return 1;
+		return 0;
+	});
+	return new PlugboyProject({
+		dir,
+		json,
+		config: skipLoadConfig ? await resolveUserProjectConfig({}) : await loadProjectConfig(dir.value, 0),
+		resolvedWorkspaces
+	});
+}
+
+//#endregion
+//#region src/postcss/plugin.ts
+async function getPostcss(options) {
+	const { layer, media, combineRules, cssnano } = options;
+	const [postcss, _layer, _media, _combineRules, _cssnano] = await Promise.all([
+		import("postcss").then((mod) => mod.default),
+		layer && import("./optimize-layer-CK8NR_VC.mjs").then((mod) => mod.OptimizeLayer(layer)),
+		media && import("./optimize-media-Bxy27Cj7.mjs").then((mod) => mod.OptimizeMedia(media)),
+		combineRules && import("./combine-rules-CWp-M491.mjs").then((mod) => mod.CombineRules(combineRules)),
+		cssnano && import("cssnano").then((mod) => mod.default(cssnano))
+	]);
+	const plugins = [];
+	_layer && plugins.push(_layer);
+	_media && plugins.push(_media);
+	_combineRules && plugins.push(_combineRules);
+	_cssnano && plugins.push(_cssnano);
+	return postcss(plugins);
+}
+const SOURCE_MAPPING_URL_COMMENT_RE = /\/\*# sourceMappingURL=.+? \*\//g;
+const allLayerDefRe = /(^|\n)@layer\s+([a-zA-Z\d\-_$. ,]+);/g;
+const layerDefTrimRe = /((^|\n)@layer\s+|;)/g;
+async function optimizeCSS(asset, options) {
+	const postcss = await getPostcss(options);
+	function prepare(css) {
+		return (() => {
+			const matched = css.match(allLayerDefRe);
+			if (!matched) return "";
+			const layerNames = [];
+			matched.forEach((row) => {
+				row.replace(layerDefTrimRe, "").split(",").forEach((chunk) => layerNames.push(chunk.trim()));
+			});
+			return `@layer ${Array.from(new Set(layerNames)).join(", ")};\n`;
+		})() + css.replace(allLayerDefRe, "");
+	}
+	const css = prepare(asset.source.toString());
+	asset.source = (await postcss.process(css, {
+		from: asset.fileName,
+		to: asset.fileName,
+		map: { inline: false }
+	})).css.replace(SOURCE_MAPPING_URL_COMMENT_RE, "");
+}
+function OptimizeCSSPlugin(workspace) {
+	return {
+		name: "plugboy-optimize-css",
+		async generateBundle(_options, bundle) {
+			const { optimizeCSSOptions } = workspace;
+			if (!optimizeCSSOptions) return;
+			for (const chunk of Object.values(bundle)) {
+				if (chunk.type !== "asset" || !chunk.fileName.endsWith(".css")) continue;
+				await optimizeCSS(chunk, optimizeCSSOptions);
+			}
+		}
+	};
+}
+
+//#endregion
+//#region src/workspace/workspace.ts
+function extractWorkspaceObjectExport(at) {
+	if (typeof at === "string") return at;
+	const { types, import: _import } = at;
+	return {
+		types,
+		import: _import
+	};
+}
+const WORKSPACE_PACKAGE_SYNC_FIELDS = [
+	"repository",
+	"author",
+	"publishConfig",
+	"license"
+];
+function syncWorkspacePackageFields(projectJSON, workspaceJSON) {
+	for (const field of WORKSPACE_PACKAGE_SYNC_FIELDS) {
+		const value = projectJSON[field];
+		if (value && !workspaceJSON[field]) workspaceJSON[field] = value;
+	}
+}
+const BUILD_TARGET_SRC_MATCH_RE = /\.(tsx?|s?css)$/;
+var PlugboyWorkspace = class {
+	name;
+	dir;
+	config;
+	project;
+	dirs;
+	dependencies;
+	projectDependencies;
+	meta;
+	entry;
+	exports;
+	builder;
+	plugins;
+	hooks;
+	dtsFiles = [];
+	dts;
+	optimizeCSSOptions;
+	_json;
+	get json() {
+		return this._json;
+	}
+	constructor(ctx) {
+		const { dir, json, config, project, dirs, dependencies, projectDependencies, meta, plugins, hooks, dts, optimizeCSS } = ctx;
+		this.name = dir.basename;
+		this.dir = dir;
+		this._json = json;
+		this.project = project;
+		this.dirs = dirs;
+		this.dependencies = dependencies;
+		this.projectDependencies = projectDependencies;
+		this.meta = meta;
+		this.config = config;
+		this.plugins = [
+			...plugins,
+			OptimizeCSSPlugin(this),
+			WorkspaceEnvPlugin(this)
+		];
+		this.hooks = hooks;
+		this.dts = dts;
+		this.optimizeCSSOptions = optimizeCSS ? resolveOptimizeCSSOptions(optimizeCSS) : false;
+		const entry = {};
+		const exports = [{
+			id: `./${PACKAGE_JSON_FILENAME}`,
+			at: `./${PACKAGE_JSON_FILENAME}`
+		}];
+		Object.entries(config.entries).forEach(([id, { src, css }]) => {
+			if (!BUILD_TARGET_SRC_MATCH_RE.test(src)) return;
+			const normalizedId = id === "." ? this.name : id;
+			const exportId = id.startsWith(".") ? id : `./${id}`;
+			const srcIsCSS = src.endsWith(".css") || src.endsWith(".scss");
+			const dest = `./dist/${normalizedId}.${srcIsCSS ? "css" : "mjs"}`;
+			const destFullPath = dir.join(dest).value;
+			entry[normalizedId] = src;
+			if (css) {
+				const cssDest = `./dist/${normalizedId}.css`;
+				exports.push({
+					id: `./${normalizedId}.css`,
+					at: cssDest,
+					stubLink: {
+						type: "css",
+						from: cssDest
+					}
+				});
+				if (srcIsCSS) return;
+			}
+			const types = `./dist/${normalizedId}.d.mts`;
+			const dtsDest = `./dist/${src.replace(/^\.\/src/, ".dts").replace(/\.ts$/, ".d.mts")}`;
+			this.dtsFiles.push(dir.join(types).value);
+			exports.push({
+				id: exportId,
+				at: {
+					src,
+					types,
+					dtsDest,
+					import: { default: dest }
+				},
+				stubLink: {
+					from: destFullPath,
+					to: path.isAbsolute(src) ? src : dir.join(src).value,
+					type: "js"
+				}
+			});
+		});
+		this.entry = entry;
+		this.exports = exports;
+		this.builder = new Builder(this);
+	}
+	clean(withDepsAndCache) {
+		const { dir, dirs } = this;
+		const paths = [dirs.dist.value];
+		if (withDepsAndCache) paths.push(dir.join("node_modules").value, dir.join(".turbo").value);
+		return rmrf(...paths);
+	}
+	async preparePackageJSON() {
+		const { exports, json, project } = this;
+		const _exports = {};
+		const typesVersions = {};
+		let main;
+		let mainTypes;
+		exports.forEach(({ id, at }) => {
+			const _at = extractWorkspaceObjectExport(at);
+			_exports[id] = _at;
+			if (typeof _at !== "object") return;
+			const isMainExport = id === ".";
+			const trimmedId = isMainExport ? id : id.replace(/^\.\//, "");
+			typesVersions[trimmedId] = [_at.types];
+			if (isMainExport) {
+				main = _at.import.default;
+				mainTypes = _at.types;
+			}
+		});
+		if (json.exports) Object.entries(json.exports).forEach(([id, at]) => {
+			const types = Object.keys(at);
+			if (types.length === 1 && types[0] === "types") _exports[id] = at;
+		});
+		_exports["./*"] = "./dist/*";
+		const originalJSONString = JSON.stringify(json);
+		const cloned = JSON.parse(originalJSONString);
+		cloned.exports = _exports;
+		cloned.typesVersions = { "*": typesVersions };
+		if (main) cloned.main = main;
+		if (mainTypes) cloned.types = mainTypes;
+		const projectPeerDependencies = project?.config.peerDependencies;
+		[
+			"dependencies",
+			"devDependencies",
+			"peerDependencies"
+		].forEach((prop) => {
+			const deps = cloned[prop];
+			if (!deps) return;
+			Object.keys(deps).forEach((dep) => {
+				if (deps[dep].startsWith(WORKSPACE_SPEC_PREFIX)) deps[dep] = `${WORKSPACE_SPEC_PREFIX}^`;
+				else if (projectPeerDependencies && projectPeerDependencies[dep] && !deps[dep]) deps[dep] = projectPeerDependencies[dep];
+			});
+		});
+		cloned.files = cloned.files || [];
+		if (!cloned.files.some((file) => /(\.\/)?dist\/?/.test(file))) cloned.files.unshift("dist");
+		if (project) syncWorkspacePackageFields(project.json, cloned);
+		cloned.type = cloned.type || "module";
+		await this.hooks.preparePackageJSON(json, this);
+		const sorted = sortPackageJson(cloned);
+		const toStr = JSON.stringify(sorted, null, 2);
+		if (originalJSONString !== toStr) {
+			await writeFileAtomic(this.dir.join(PACKAGE_JSON_FILENAME).value, toStr);
+			this._json = sorted;
+		}
+		return sorted;
+	}
+	getStubLinks() {
+		const links = [];
+		this.exports.forEach(({ stubLink }) => {
+			stubLink && links.push(stubLink);
+		});
+		return links;
+	}
+	async stub() {
+		await this.clean();
+		await fs$1.mkdir(this.dirs.dist.value);
+		return this.builder.stub();
+	}
+	async build() {
+		await this.clean();
+		return this.builder.build();
+	}
+};
+async function getWorkspace(searchDir, allowMissing) {
+	const hit = await getWorkspacePackageJson(searchDir, allowMissing);
+	if (!hit) return null;
+	const { dir, json } = hit;
+	const config = await loadWorkspaceConfig(dir.value, 0);
+	const project = await getProject(dir.value, true, config.ignoreProjectConfig);
+	const dirs = {
+		src: dir.join("src"),
+		dist: dir.join("dist")
+	};
+	const { dependencies, peerDependencies, optionalDependencies } = json;
+	const allDeps = {
+		...dependencies,
+		...peerDependencies,
+		...optionalDependencies
+	};
+	const _dependencies = Object.keys(allDeps);
+	const projectDependencies = Object.entries(allDeps).filter(([dep, spec]) => spec.startsWith(WORKSPACE_SPEC_PREFIX)).map(([dep]) => dep);
+	const meta = {};
+	const projectPlugins = project?.plugins || [];
+	const projectHooks = project?.hooks || [];
+	const plugins = [...projectPlugins, ...config.plugins];
+	const _hooks = [...projectHooks];
+	if (config.hooks) _hooks.push(config.hooks);
+	for (const plugin of config.plugins) if (plugin.hooks) _hooks.push(plugin.hooks);
+	const hooks = buildHooks(await resolveUserHooks(..._hooks));
+	const dts = mergeDTSSettingsList(project?.config.dts, config.dts);
+	let { optimizeCSS } = config;
+	if (optimizeCSS !== false && project && project.config.optimizeCSS) optimizeCSS = {
+		...project.config.optimizeCSS,
+		...optimizeCSS
+	};
+	const ctx = {
+		dir,
+		json,
+		config,
+		project,
+		dirs,
+		dependencies: _dependencies,
+		projectDependencies,
+		meta,
+		plugins,
+		hooks,
+		dts,
+		optimizeCSS,
+		mergeExternals: (override) => {
+			config.external = mergeExternals(config.external, override);
+		},
+		mergeNoExternals: (override) => {
+			config.noExternal = mergeNoExternals(config.noExternal, override);
+		}
+	};
+	await hooks.setupWorkspace(ctx, () => {
+		return typeof workspace === "undefined" ? void 0 : workspace;
+	});
+	const workspace = new PlugboyWorkspace(ctx);
+	await hooks.createWorkspace(workspace);
+	return workspace;
+}
+
+//#endregion
+//#region src/workspace/generate.ts
+async function generateWorkspace(workspaceName, cwd = process.cwd()) {
+	const project = await getProject(cwd);
+	const { config } = project;
+	while (!workspaceName) {
+		const value = await prompts.input({ message: "Enter a workspace name" });
+		if (value) workspaceName = value;
+	}
+	const description = await prompts.input({
+		default: workspaceName,
+		message: "Please enter a description of your package"
+	});
+	let version;
+	while (!version) {
+		const value = await prompts.input({
+			default: "0.0.0",
+			message: "Please enter the initial version"
+		});
+		if (value) version = value;
+	}
+	const keywords = (await prompts.input({ message: "Enter as many keywords, if any, as needed, separated by commas" })).split(",").map((word) => word.trim()).filter((word) => word.length);
+	const scriptsTemplates = config.scripts;
+	let scriptsTemplate;
+	if (scriptsTemplates && scriptsTemplates.length) {
+		const value = await prompts.rawlist({
+			message: "Select a scripts template",
+			choices: [{
+				name: "None",
+				value: ""
+			}, ...scriptsTemplates.map((tpl) => ({
+				name: tpl.name,
+				value: tpl.name
+			}))]
+		});
+		scriptsTemplate = scriptsTemplates.find((tpl) => tpl.name === value);
+	}
+	const scripts = scriptsTemplate?.scripts || {};
+	const peerDependencies = await (async () => {
+		const deps = await prompts.checkbox({
+			message: "Select the dependent packages, if any, to be used in the package",
+			choices: Object.keys(config.peerDependencies).map((dep) => ({
+				name: dep,
+				value: dep
+			}))
+		});
+		if (!deps.length) return;
+		return Object.fromEntries(deps.map((dep) => [dep, config.peerDependencies[dep]]));
+	})();
+	const dependencies = await (async () => {
+		const deps = await prompts.checkbox({
+			message: "Select the internal package to be used, if any.",
+			choices: project.resolvedWorkspaces.map((workspace) => {
+				const name = path.basename(workspace);
+				return {
+					name,
+					value: name
+				};
+			})
+		});
+		if (!deps.length) return;
+		return Object.fromEntries(deps.map((dep) => [`@${project.name}/${dep}`, `${WORKSPACE_SPEC_PREFIX}^`]));
+	})();
+	const withGenSource = await prompts.confirm({
+		message: "Generate source files?",
+		default: true
+	});
+	const _json = {
+		name: `@${project.name}/${workspaceName}`,
+		type: "module",
+		description,
+		version,
+		keywords,
+		scripts,
+		peerDependencies,
+		dependencies
+	};
+	syncWorkspacePackageFields(project.json, _json);
+	const json = sortPackageJson(_json);
+	const workspaceDir = path.join(config.workspacesDir, workspaceName);
+	console.log("");
+	console.log("========================================");
+	console.log(`Directory: ${workspaceDir}`);
+	console.log(`Generate source: ${withGenSource ? "Yes" : "No"}`);
+	console.log(json);
+	console.log("========================================");
+	if (!await prompts.confirm({
+		message: "Is this OK?",
+		default: true
+	})) {
+		console.log("Skipped.");
+		process.exit(1);
+	}
+	await fs$1.mkdir(workspaceDir);
+	await fs$1.writeFile(path.join(workspaceDir, "package.json"), JSON.stringify(json, null, 2));
+	await fs$1.writeFile(path.join(workspaceDir, "README.md"), config.readme(json));
+	if (withGenSource) {
+		const srcDir = path.join(workspaceDir, "src");
+		await fs$1.mkdir(srcDir);
+		const indexCode = `export * from './${workspaceName}';\n`;
+		const modCode = `export const PACKAGE_NAME = './${workspaceName}';\n`;
+		await fs$1.writeFile(path.join(srcDir, "index.ts"), indexCode);
+		await fs$1.writeFile(path.join(srcDir, `${workspaceName}.ts`), modCode);
+		const { tsconfig } = config;
+		if (tsconfig) await fs$1.writeFile(path.join(workspaceDir, "tsconfig.json"), JSON.stringify(tsconfig, null, 2));
+		const configFileCode = `${`
+import { defineWorkspaceConfig } from '@fastkit/plugboy';
+
+export default defineWorkspaceConfig({
+  entries: {
+    '.': './src/index.ts',
+  },
+});
+    `.trim()}\n`;
+		await fs$1.writeFile(path.join(workspaceDir, `${WORKSPACE_CONFIG_BASENAME}.ts`), configFileCode);
+		await (await getWorkspace(workspaceDir)).preparePackageJSON();
+	}
+}
+
+//#endregion
+export { normalizeDTSSettings as $, resolveRawExposeEntriesSettings as A, exitHook as B, findProjectPlugin as C, loadProjectConfig as D, isProjectPackageJson as E, getFilename as F, resolveListable as G, mergeExternals as H, isFileNotFoundException as I, WORKSPACE_REQUIRED_FIELDS as J, PROJECT_REQUIRED_FIELDS as K, pathExists as L, findConfig as M, findFile as N, resolveUserProjectConfig as O, getDirname as P, normalizeDTSPreserveTypeTarget as Q, rmrf as R, extractProjectPlugins as S, defineProjectConfig as T, mergeNoExternals as U, mergeChunkAddons as V, isPromise as W, mergeDTSSettingsList as X, resolveOptimizeCSSOptions as Y, normalizeDTSPreserveTypeSettings as Z, loadWorkspaceConfig as _, syncWorkspacePackageFields as a, resolveUserWorkspaceConfig as b, Builder as c, getWorkspacePackageJson as d, createHooksDefaults as et, Path as f, isWorkspacePackageJson as g, defineWorkspaceConfig as h, getWorkspace as i, copyDirSync as j, exposeEntries as k, findWorkspacePackages as l, resolveUserHooks as m, PlugboyWorkspace as n, PlugboyProject as o, buildHooks as p, TSDOWN_SYNC_OPTIONS as q, WORKSPACE_PACKAGE_SYNC_FIELDS as r, getProject as s, generateWorkspace as t, getProjectPackageJson as u, resolveRawWorkspaceEntries as v, resolveUserPluginOption as w, definePlugin as x, resolveRawWorkspaceEntry as y, writeFileAtomic as z };
+//# sourceMappingURL=workspace-BqcryYAT.mjs.map