@bleedingdev/modern-js-create 3.2.0-ultramodern.0

package/dist/index.js

@@ -0,0 +1,2320 @@
+import node_crypto from "node:crypto";
+import node_fs from "node:fs";
+import node_path from "node:path";
+import node_readline from "node:readline";
+import { fileURLToPath } from "node:url";
+import "node:module";
+class I18CLILanguageDetector {
+    formatShellLocale(rawLC) {
+        if (!rawLC) return '';
+        const LCs = rawLC.split(':');
+        const LC = LCs[0].split('.')[0].split('_')[0].split('-')[0];
+        if ('C' === LC) return '';
+        return LC;
+    }
+    detect() {
+        const env = globalThis.process?.env;
+        const shellLocale = env?.LC_ALL ?? env?.LC_MESSAGES ?? env?.LANG ?? env?.LANGUAGE ?? Intl.DateTimeFormat().resolvedOptions().locale;
+        return this.formatShellLocale(shellLocale);
+    }
+}
+function getLocaleLanguage() {
+    const detector = new I18CLILanguageDetector();
+    return detector.detect();
+}
+var isArray = Array.isArray;
+const lodash_es_isArray = isArray;
+var freeGlobal = 'object' == typeof global && global && global.Object === Object && global;
+const _freeGlobal = freeGlobal;
+var freeSelf = 'object' == typeof self && self && self.Object === Object && self;
+var _root_root = _freeGlobal || freeSelf || Function('return this')();
+const _root = _root_root;
+var Symbol = _root.Symbol;
+const _Symbol = Symbol;
+var objectProto = Object.prototype;
+var _getRawTag_hasOwnProperty = objectProto.hasOwnProperty;
+var nativeObjectToString = objectProto.toString;
+var symToStringTag = _Symbol ? _Symbol.toStringTag : void 0;
+function getRawTag(value) {
+    var isOwn = _getRawTag_hasOwnProperty.call(value, symToStringTag), tag = value[symToStringTag];
+    try {
+        value[symToStringTag] = void 0;
+        var unmasked = true;
+    } catch (e) {}
+    var result = nativeObjectToString.call(value);
+    if (unmasked) if (isOwn) value[symToStringTag] = tag;
+    else delete value[symToStringTag];
+    return result;
+}
+const _getRawTag = getRawTag;
+var _objectToString_objectProto = Object.prototype;
+var _objectToString_nativeObjectToString = _objectToString_objectProto.toString;
+function objectToString(value) {
+    return _objectToString_nativeObjectToString.call(value);
+}
+const _objectToString = objectToString;
+var nullTag = '[object Null]', undefinedTag = '[object Undefined]';
+var _baseGetTag_symToStringTag = _Symbol ? _Symbol.toStringTag : void 0;
+function baseGetTag(value) {
+    if (null == value) return void 0 === value ? undefinedTag : nullTag;
+    return _baseGetTag_symToStringTag && _baseGetTag_symToStringTag in Object(value) ? _getRawTag(value) : _objectToString(value);
+}
+const _baseGetTag = baseGetTag;
+function isObjectLike(value) {
+    return null != value && 'object' == typeof value;
+}
+const lodash_es_isObjectLike = isObjectLike;
+var symbolTag = '[object Symbol]';
+function isSymbol(value) {
+    return 'symbol' == typeof value || lodash_es_isObjectLike(value) && _baseGetTag(value) == symbolTag;
+}
+const lodash_es_isSymbol = isSymbol;
+var reIsDeepProp = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/, reIsPlainProp = /^\w*$/;
+function isKey(value, object) {
+    if (lodash_es_isArray(value)) return false;
+    var type = typeof value;
+    if ('number' == type || 'symbol' == type || 'boolean' == type || null == value || lodash_es_isSymbol(value)) return true;
+    return reIsPlainProp.test(value) || !reIsDeepProp.test(value) || null != object && value in Object(object);
+}
+const _isKey = isKey;
+function isObject(value) {
+    var type = typeof value;
+    return null != value && ('object' == type || 'function' == type);
+}
+const lodash_es_isObject = isObject;
+var asyncTag = '[object AsyncFunction]', funcTag = '[object Function]', genTag = '[object GeneratorFunction]', proxyTag = '[object Proxy]';
+function isFunction(value) {
+    if (!lodash_es_isObject(value)) return false;
+    var tag = _baseGetTag(value);
+    return tag == funcTag || tag == genTag || tag == asyncTag || tag == proxyTag;
+}
+const lodash_es_isFunction = isFunction;
+var coreJsData = _root["__core-js_shared__"];
+const _coreJsData = coreJsData;
+var maskSrcKey = function() {
+    var uid = /[^.]+$/.exec(_coreJsData && _coreJsData.keys && _coreJsData.keys.IE_PROTO || '');
+    return uid ? 'Symbol(src)_1.' + uid : '';
+}();
+function isMasked(func) {
+    return !!maskSrcKey && maskSrcKey in func;
+}
+const _isMasked = isMasked;
+var funcProto = Function.prototype;
+var funcToString = funcProto.toString;
+function toSource(func) {
+    if (null != func) {
+        try {
+            return funcToString.call(func);
+        } catch (e) {}
+        try {
+            return func + '';
+        } catch (e) {}
+    }
+    return '';
+}
+const _toSource = toSource;
+var reRegExpChar = /[\\^$.*+?()[\]{}|]/g;
+var reIsHostCtor = /^\[object .+?Constructor\]$/;
+var _baseIsNative_funcProto = Function.prototype, _baseIsNative_objectProto = Object.prototype;
+var _baseIsNative_funcToString = _baseIsNative_funcProto.toString;
+var _baseIsNative_hasOwnProperty = _baseIsNative_objectProto.hasOwnProperty;
+var reIsNative = RegExp('^' + _baseIsNative_funcToString.call(_baseIsNative_hasOwnProperty).replace(reRegExpChar, '\\$&').replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, '$1.*?') + '$');
+function baseIsNative(value) {
+    if (!lodash_es_isObject(value) || _isMasked(value)) return false;
+    var pattern = lodash_es_isFunction(value) ? reIsNative : reIsHostCtor;
+    return pattern.test(_toSource(value));
+}
+const _baseIsNative = baseIsNative;
+function getValue(object, key) {
+    return null == object ? void 0 : object[key];
+}
+const _getValue = getValue;
+function getNative(object, key) {
+    var value = _getValue(object, key);
+    return _baseIsNative(value) ? value : void 0;
+}
+const _getNative = getNative;
+var nativeCreate = _getNative(Object, 'create');
+const _nativeCreate = nativeCreate;
+function hashClear() {
+    this.__data__ = _nativeCreate ? _nativeCreate(null) : {};
+    this.size = 0;
+}
+const _hashClear = hashClear;
+function hashDelete(key) {
+    var result = this.has(key) && delete this.__data__[key];
+    this.size -= result ? 1 : 0;
+    return result;
+}
+const _hashDelete = hashDelete;
+var HASH_UNDEFINED = '__lodash_hash_undefined__';
+var _hashGet_objectProto = Object.prototype;
+var _hashGet_hasOwnProperty = _hashGet_objectProto.hasOwnProperty;
+function hashGet(key) {
+    var data = this.__data__;
+    if (_nativeCreate) {
+        var result = data[key];
+        return result === HASH_UNDEFINED ? void 0 : result;
+    }
+    return _hashGet_hasOwnProperty.call(data, key) ? data[key] : void 0;
+}
+const _hashGet = hashGet;
+var _hashHas_objectProto = Object.prototype;
+var _hashHas_hasOwnProperty = _hashHas_objectProto.hasOwnProperty;
+function hashHas(key) {
+    var data = this.__data__;
+    return _nativeCreate ? void 0 !== data[key] : _hashHas_hasOwnProperty.call(data, key);
+}
+const _hashHas = hashHas;
+var _hashSet_HASH_UNDEFINED = '__lodash_hash_undefined__';
+function hashSet(key, value) {
+    var data = this.__data__;
+    this.size += this.has(key) ? 0 : 1;
+    data[key] = _nativeCreate && void 0 === value ? _hashSet_HASH_UNDEFINED : value;
+    return this;
+}
+const _hashSet = hashSet;
+function Hash(entries) {
+    var index = -1, length = null == entries ? 0 : entries.length;
+    this.clear();
+    while(++index < length){
+        var entry = entries[index];
+        this.set(entry[0], entry[1]);
+    }
+}
+Hash.prototype.clear = _hashClear;
+Hash.prototype['delete'] = _hashDelete;
+Hash.prototype.get = _hashGet;
+Hash.prototype.has = _hashHas;
+Hash.prototype.set = _hashSet;
+const _Hash = Hash;
+function listCacheClear() {
+    this.__data__ = [];
+    this.size = 0;
+}
+const _listCacheClear = listCacheClear;
+function eq(value, other) {
+    return value === other || value !== value && other !== other;
+}
+const lodash_es_eq = eq;
+function assocIndexOf(array, key) {
+    var length = array.length;
+    while(length--)if (lodash_es_eq(array[length][0], key)) return length;
+    return -1;
+}
+const _assocIndexOf = assocIndexOf;
+var arrayProto = Array.prototype;
+var splice = arrayProto.splice;
+function listCacheDelete(key) {
+    var data = this.__data__, index = _assocIndexOf(data, key);
+    if (index < 0) return false;
+    var lastIndex = data.length - 1;
+    if (index == lastIndex) data.pop();
+    else splice.call(data, index, 1);
+    --this.size;
+    return true;
+}
+const _listCacheDelete = listCacheDelete;
+function listCacheGet(key) {
+    var data = this.__data__, index = _assocIndexOf(data, key);
+    return index < 0 ? void 0 : data[index][1];
+}
+const _listCacheGet = listCacheGet;
+function listCacheHas(key) {
+    return _assocIndexOf(this.__data__, key) > -1;
+}
+const _listCacheHas = listCacheHas;
+function listCacheSet(key, value) {
+    var data = this.__data__, index = _assocIndexOf(data, key);
+    if (index < 0) {
+        ++this.size;
+        data.push([
+            key,
+            value
+        ]);
+    } else data[index][1] = value;
+    return this;
+}
+const _listCacheSet = listCacheSet;
+function ListCache(entries) {
+    var index = -1, length = null == entries ? 0 : entries.length;
+    this.clear();
+    while(++index < length){
+        var entry = entries[index];
+        this.set(entry[0], entry[1]);
+    }
+}
+ListCache.prototype.clear = _listCacheClear;
+ListCache.prototype['delete'] = _listCacheDelete;
+ListCache.prototype.get = _listCacheGet;
+ListCache.prototype.has = _listCacheHas;
+ListCache.prototype.set = _listCacheSet;
+const _ListCache = ListCache;
+var Map = _getNative(_root, 'Map');
+const _Map = Map;
+function mapCacheClear() {
+    this.size = 0;
+    this.__data__ = {
+        hash: new _Hash,
+        map: new (_Map || _ListCache),
+        string: new _Hash
+    };
+}
+const _mapCacheClear = mapCacheClear;
+function isKeyable(value) {
+    var type = typeof value;
+    return 'string' == type || 'number' == type || 'symbol' == type || 'boolean' == type ? '__proto__' !== value : null === value;
+}
+const _isKeyable = isKeyable;
+function getMapData(map, key) {
+    var data = map.__data__;
+    return _isKeyable(key) ? data['string' == typeof key ? 'string' : 'hash'] : data.map;
+}
+const _getMapData = getMapData;
+function mapCacheDelete(key) {
+    var result = _getMapData(this, key)['delete'](key);
+    this.size -= result ? 1 : 0;
+    return result;
+}
+const _mapCacheDelete = mapCacheDelete;
+function mapCacheGet(key) {
+    return _getMapData(this, key).get(key);
+}
+const _mapCacheGet = mapCacheGet;
+function mapCacheHas(key) {
+    return _getMapData(this, key).has(key);
+}
+const _mapCacheHas = mapCacheHas;
+function mapCacheSet(key, value) {
+    var data = _getMapData(this, key), size = data.size;
+    data.set(key, value);
+    this.size += data.size == size ? 0 : 1;
+    return this;
+}
+const _mapCacheSet = mapCacheSet;
+function MapCache(entries) {
+    var index = -1, length = null == entries ? 0 : entries.length;
+    this.clear();
+    while(++index < length){
+        var entry = entries[index];
+        this.set(entry[0], entry[1]);
+    }
+}
+MapCache.prototype.clear = _mapCacheClear;
+MapCache.prototype['delete'] = _mapCacheDelete;
+MapCache.prototype.get = _mapCacheGet;
+MapCache.prototype.has = _mapCacheHas;
+MapCache.prototype.set = _mapCacheSet;
+const _MapCache = MapCache;
+var FUNC_ERROR_TEXT = 'Expected a function';
+function memoize(func, resolver) {
+    if ('function' != typeof func || null != resolver && 'function' != typeof resolver) throw new TypeError(FUNC_ERROR_TEXT);
+    var memoized = function() {
+        var args = arguments, key = resolver ? resolver.apply(this, args) : args[0], cache = memoized.cache;
+        if (cache.has(key)) return cache.get(key);
+        var result = func.apply(this, args);
+        memoized.cache = cache.set(key, result) || cache;
+        return result;
+    };
+    memoized.cache = new (memoize.Cache || _MapCache);
+    return memoized;
+}
+memoize.Cache = _MapCache;
+const lodash_es_memoize = memoize;
+var MAX_MEMOIZE_SIZE = 500;
+function memoizeCapped(func) {
+    var result = lodash_es_memoize(func, function(key) {
+        if (cache.size === MAX_MEMOIZE_SIZE) cache.clear();
+        return key;
+    });
+    var cache = result.cache;
+    return result;
+}
+const _memoizeCapped = memoizeCapped;
+var rePropName = /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g;
+var reEscapeChar = /\\(\\)?/g;
+var stringToPath = _memoizeCapped(function(string) {
+    var result = [];
+    if (46 === string.charCodeAt(0)) result.push('');
+    string.replace(rePropName, function(match, number, quote, subString) {
+        result.push(quote ? subString.replace(reEscapeChar, '$1') : number || match);
+    });
+    return result;
+});
+const _stringToPath = stringToPath;
+function arrayMap(array, iteratee) {
+    var index = -1, length = null == array ? 0 : array.length, result = Array(length);
+    while(++index < length)result[index] = iteratee(array[index], index, array);
+    return result;
+}
+const _arrayMap = arrayMap;
+var INFINITY = 1 / 0;
+var symbolProto = _Symbol ? _Symbol.prototype : void 0, symbolToString = symbolProto ? symbolProto.toString : void 0;
+function baseToString(value) {
+    if ('string' == typeof value) return value;
+    if (lodash_es_isArray(value)) return _arrayMap(value, baseToString) + '';
+    if (lodash_es_isSymbol(value)) return symbolToString ? symbolToString.call(value) : '';
+    var result = value + '';
+    return '0' == result && 1 / value == -INFINITY ? '-0' : result;
+}
+const _baseToString = baseToString;
+function toString_toString(value) {
+    return null == value ? '' : _baseToString(value);
+}
+const lodash_es_toString = toString_toString;
+function castPath(value, object) {
+    if (lodash_es_isArray(value)) return value;
+    return _isKey(value, object) ? [
+        value
+    ] : _stringToPath(lodash_es_toString(value));
+}
+const _castPath = castPath;
+var _toKey_INFINITY = 1 / 0;
+function toKey(value) {
+    if ('string' == typeof value || lodash_es_isSymbol(value)) return value;
+    var result = value + '';
+    return '0' == result && 1 / value == -_toKey_INFINITY ? '-0' : result;
+}
+const _toKey = toKey;
+function baseGet(object, path) {
+    path = _castPath(path, object);
+    var index = 0, length = path.length;
+    while(null != object && index < length)object = object[_toKey(path[index++])];
+    return index && index == length ? object : void 0;
+}
+const _baseGet = baseGet;
+function get(object, path, defaultValue) {
+    var result = null == object ? void 0 : _baseGet(object, path);
+    return void 0 === result ? defaultValue : result;
+}
+const lodash_es_get = get;
+var stringTag = '[object String]';
+function isString(value) {
+    return 'string' == typeof value || !lodash_es_isArray(value) && lodash_es_isObjectLike(value) && _baseGetTag(value) == stringTag;
+}
+const lodash_es_isString = isString;
+function getObjKeyMap(obj, prefix = '') {
+    const result = {};
+    Object.keys(obj).forEach((key)=>{
+        if (lodash_es_isString(obj[key])) result[key] = prefix ? `${prefix}.${key}` : key;
+        else if (lodash_es_isObject(obj[key])) result[key] = getObjKeyMap(obj[key], prefix ? `${prefix}.${key}` : key);
+    });
+    return result;
+}
+class I18n {
+    format(msg, vars) {
+        return msg.replace(/\{(\w+)\}/g, (_match, capture)=>Object.prototype.hasOwnProperty.call(vars, capture) ? vars[capture] : capture);
+    }
+    getMessage(lang, key, vars, fallbackText) {
+        const languages = Object.keys(this.languageMap);
+        const resultLang = languages.find((l)=>l === lang);
+        if (!resultLang && 0 === languages.length) return fallbackText || key;
+        const model = this.languageMap[resultLang || 'en'];
+        if (!model) return fallbackText || key;
+        const message = lodash_es_get(model, key);
+        const value = message || fallbackText || key;
+        if ('string' == typeof value) return this.format(value, vars || {});
+        throw new Error('key is not a string');
+    }
+    init(language, languageMap) {
+        this.language = language || 'en';
+        if (languageMap) this.languageMap = languageMap;
+        return getObjKeyMap(this.languageMap[this.language]);
+    }
+    changeLanguage(config) {
+        this.language = config.locale || 'en';
+    }
+    t(key, vars, fallbackText) {
+        return this.getMessage(this.language, key, vars, fallbackText);
+    }
+    lang(lang) {
+        return {
+            t: (key, vars, fallbackText)=>this.getMessage(lang, key, vars, fallbackText)
+        };
+    }
+    constructor(){
+        this.language = 'en';
+        this.languageMap = {};
+    }
+}
+const EN_LOCALE = {
+    prompt: {
+        projectName: 'Please enter project name: '
+    },
+    error: {
+        projectNameEmpty: 'Error: Project name cannot be empty',
+        directoryExists: 'Error: Directory "{projectName}" already exists and is not empty',
+        invalidRouter: 'Error: Unsupported router "{router}". Use "react-router" or "tanstack".',
+        invalidBffRuntime: 'Error: Unsupported BFF runtime "{runtime}". Use "hono" or "effect".',
+        createFailed: 'Error creating project:'
+    },
+    message: {
+        welcome: '🚀 Welcome to Modern.js',
+        success: '✨ Created successfully!',
+        nextSteps: '📋 Next steps:',
+        step1: 'cd {projectName}',
+        step2: 'pnpm install',
+        step3: 'pnpm dev'
+    },
+    help: {
+        title: '🚀 Modern.js Project Creator',
+        description: 'Create a new Modern.js project with ease',
+        usage: '📖 Usage:',
+        usageExample: '  create [project-name] [options]',
+        options: '⚙️  Options:',
+        optionHelp: '  -h, --help     Display this help message',
+        optionVersion: '  -v, --version  Display version information',
+        optionLang: '  -l, --lang     Set the language (zh or en)',
+        optionRouter: '  -r, --router   Select router framework (react-router or tanstack)',
+        optionBff: '      --bff      Enable BFF scaffold (default runtime: effect)',
+        optionBffRuntime: '      --bff-runtime Select BFF runtime (hono or effect)',
+        optionTailwind: '      --tailwind Enable Tailwind CSS v4 scaffold (PostCSS + starter styles)',
+        optionWorkspace: '      --workspace Use workspace protocol for @modern-js dependencies (for local monorepo testing)',
+        optionUltramodernWorkspace: '      --ultramodern-workspace Generate the canonical UltraModern SuperApp workspace',
+        optionUltramodernPackageSource: '      --ultramodern-package-source Select UltraModern package source (workspace or install)',
+        optionUltramodernPackageScope: '      --ultramodern-package-scope Publish scope for npm alias installs (for example bleedingdev)',
+        optionUltramodernPackageNamePrefix: '      --ultramodern-package-name-prefix Prefix for npm alias package names (default: modern-js-)',
+        optionSub: '  -s, --sub       Mark as a subproject (package in monorepo)',
+        examples: '💡 Examples:',
+        example1: '  create my-app',
+        example2: '  create my-app --lang zh',
+        example3: '  create my-app --sub',
+        example4: '  create --help',
+        example5: '  create my-app --router tanstack',
+        example6: '  create my-app --router tanstack --tailwind',
+        example7: '  create my-app --bff',
+        example8: '  create my-app --router tanstack --bff-runtime effect',
+        example9: '  create my-app --router tanstack --bff-runtime effect --workspace',
+        example10: '  create my-super-app --ultramodern-workspace --ultramodern-package-source install --ultramodern-package-scope bleedingdev',
+        moreInfo: '📚 Learn more: https://modernjs.dev'
+    },
+    version: {
+        message: '@modern-js/create version: {version}'
+    }
+};
+const ZH_LOCALE = {
+    prompt: {
+        projectName: '请输入项目名称: '
+    },
+    error: {
+        projectNameEmpty: '错误: 项目名称不能为空',
+        directoryExists: '错误: 目录 "{projectName}" 已存在且不为空',
+        invalidRouter: '错误: 不支持的路由器 "{router}"，请使用 "react-router" 或 "tanstack"',
+        invalidBffRuntime: '错误: 不支持的 BFF 运行时 "{runtime}"，请使用 "hono" 或 "effect"',
+        createFailed: '创建项目时出错:'
+    },
+    message: {
+        welcome: '🚀 欢迎使用 Modern.js',
+        success: '✨ 创建成功！',
+        nextSteps: '📋 下一步：',
+        step1: 'cd {projectName}',
+        step2: 'pnpm install',
+        step3: 'pnpm dev'
+    },
+    help: {
+        title: '🚀 Modern.js 项目创建工具',
+        description: '快速创建一个新的 Modern.js 项目',
+        usage: '📖 用法:',
+        usageExample: '  create [项目名称] [选项]',
+        options: '⚙️  选项:',
+        optionHelp: '  -h, --help     显示帮助信息',
+        optionVersion: '  -v, --version  显示版本信息',
+        optionLang: '  -l, --lang     设置语言 (zh 或 en)',
+        optionRouter: '  -r, --router   选择路由框架 (react-router 或 tanstack)',
+        optionBff: '      --bff      启用 BFF 模板（默认运行时：effect）',
+        optionBffRuntime: '      --bff-runtime 选择 BFF 运行时（hono 或 effect）',
+        optionTailwind: '      --tailwind 启用 Tailwind CSS v4 模板（PostCSS + 示例样式）',
+        optionWorkspace: '      --workspace 对 @modern-js 依赖使用 workspace 协议（用于本地 monorepo 联调）',
+        optionUltramodernWorkspace: '      --ultramodern-workspace 生成标准 UltraModern SuperApp 工作区',
+        optionUltramodernPackageSource: '      --ultramodern-package-source 选择 UltraModern 依赖来源（workspace 或 install）',
+        optionUltramodernPackageScope: '      --ultramodern-package-scope npm alias 安装使用的发布 scope（例如 bleedingdev）',
+        optionUltramodernPackageNamePrefix: '      --ultramodern-package-name-prefix npm alias 包名前缀（默认：modern-js-）',
+        optionSub: '  -s, --sub       标记为子项目（monorepo 中的子包）',
+        examples: '💡 示例:',
+        example1: '  create my-app',
+        example2: '  create my-app --lang zh',
+        example3: '  create my-app --sub',
+        example4: '  create --help',
+        example5: '  create my-app --router tanstack',
+        example6: '  create my-app --router tanstack --tailwind',
+        example7: '  create my-app --bff',
+        example8: '  create my-app --router tanstack --bff-runtime effect',
+        example9: '  create my-app --router tanstack --bff-runtime effect --workspace',
+        example10: '  create my-super-app --ultramodern-workspace --ultramodern-package-source install --ultramodern-package-scope bleedingdev',
+        moreInfo: '📚 更多信息: https://modernjs.dev'
+    },
+    version: {
+        message: '@modern-js/create 版本: {version}'
+    }
+};
+const i18n = new I18n();
+const localeKeys = i18n.init('en', {
+    zh: ZH_LOCALE,
+    en: EN_LOCALE
+});
+const ultramodern_workspace_dirname = node_path.dirname(fileURLToPath(import.meta.url));
+const workspaceTemplateDir = node_path.resolve(ultramodern_workspace_dirname, '..', 'template-workspace');
+const TANSTACK_ROUTER_VERSION = '1.170.1';
+const MODULE_FEDERATION_VERSION = '2.4.0';
+const TYPESCRIPT_VERSION = '6.0.3';
+const REACT_VERSION = '^19.2.6';
+const REACT_DOM_VERSION = '^19.2.6';
+const WORKSPACE_PACKAGE_VERSION = 'workspace:*';
+const modernPackageNames = [
+    '@modern-js/app-tools',
+    '@modern-js/plugin-bff',
+    '@modern-js/plugin-tanstack',
+    '@modern-js/runtime'
+];
+const ULTRAMODERN_WORKSPACE_FLAG = '--ultramodern-workspace';
+const shellApp = {
+    id: 'shell-super-app',
+    directory: 'apps/shell-super-app',
+    packageSuffix: 'shell-super-app',
+    displayName: 'Shell Super App',
+    kind: 'shell',
+    portEnv: 'SHELL_SUPER_APP_PORT',
+    port: 3020,
+    mfName: 'shellSuperApp',
+    remoteRefs: [
+        'remote-commerce',
+        'remote-identity',
+        'remote-design-system'
+    ],
+    ownership: {
+        team: 'super-app-platform',
+        slack: '#super-app-platform',
+        pagerDuty: 'pd-super-app-platform',
+        runbookRef: 'runbooks/wave2/shell-super-app.md',
+        adrRef: 'docs/super-app-rfc-adr/wave2/reference-topology.md#shell-super-app',
+        blastRadius: {
+            tier: 'tier-0-shell',
+            references: [
+                'docs/super-app-rfc-adr/wave2/blast-radius.md#shell',
+                'docs/super-app-rfc-adr/wave2/rollback.md#shell-lkg'
+            ]
+        }
+    }
+};
+const remoteApps = [
+    {
+        id: 'remote-commerce',
+        directory: 'apps/remotes/remote-commerce',
+        packageSuffix: 'remote-commerce',
+        displayName: 'Commerce Remote',
+        kind: 'vertical',
+        domain: 'commerce',
+        portEnv: 'REMOTE_COMMERCE_PORT',
+        port: 3021,
+        mfName: 'remoteCommerce',
+        exposes: {
+            './Route': './src/remote-entry.tsx',
+            './Widget': './src/components/CommerceWidget.tsx'
+        },
+        ownership: {
+            team: 'commerce-experience',
+            slack: '#commerce-experience',
+            pagerDuty: 'pd-commerce-experience',
+            runbookRef: 'runbooks/wave2/remote-commerce.md',
+            adrRef: 'docs/super-app-rfc-adr/wave2/reference-topology.md#remote-commerce',
+            blastRadius: {
+                tier: 'tier-1-revenue-path',
+                references: [
+                    'docs/super-app-rfc-adr/wave2/blast-radius.md#commerce',
+                    'docs/super-app-rfc-adr/wave2/rollback.md#commerce-lkg'
+                ]
+            }
+        }
+    },
+    {
+        id: 'remote-identity',
+        directory: 'apps/remotes/remote-identity',
+        packageSuffix: 'remote-identity',
+        displayName: 'Identity Remote',
+        kind: 'vertical',
+        domain: 'identity',
+        portEnv: 'REMOTE_IDENTITY_PORT',
+        port: 3022,
+        mfName: 'remoteIdentity',
+        exposes: {
+            './Route': './src/remote-entry.tsx',
+            './Widget': './src/components/IdentityWidget.tsx'
+        },
+        ownership: {
+            team: 'identity-platform',
+            slack: '#identity-platform',
+            pagerDuty: 'pd-identity-platform',
+            runbookRef: 'runbooks/wave2/remote-identity.md',
+            adrRef: 'docs/super-app-rfc-adr/wave2/reference-topology.md#remote-identity',
+            blastRadius: {
+                tier: 'tier-0-authentication',
+                references: [
+                    'docs/super-app-rfc-adr/wave2/blast-radius.md#identity',
+                    'docs/super-app-rfc-adr/wave2/rollback.md#identity-lkg'
+                ]
+            }
+        }
+    },
+    {
+        id: 'remote-design-system',
+        directory: 'apps/remotes/remote-design-system',
+        packageSuffix: 'remote-design-system',
+        displayName: 'Design System Remote',
+        kind: 'horizontal-design-system',
+        domain: 'design-system',
+        portEnv: 'REMOTE_DESIGN_SYSTEM_PORT',
+        port: 3023,
+        mfName: 'remoteDesignSystem',
+        exposes: {
+            './Button': './src/components/Button.tsx',
+            './tokens': './src/tokens.ts'
+        },
+        ownership: {
+            team: 'design-platform',
+            slack: '#design-platform',
+            pagerDuty: 'pd-design-platform',
+            runbookRef: 'runbooks/wave2/remote-design-system.md',
+            adrRef: 'docs/super-app-rfc-adr/wave2/reference-topology.md#remote-design-system',
+            blastRadius: {
+                tier: 'tier-0-shared-ui',
+                references: [
+                    'docs/super-app-rfc-adr/wave2/blast-radius.md#design-system',
+                    'docs/super-app-rfc-adr/wave2/rollback.md#design-system-pins'
+                ]
+            }
+        }
+    }
+];
+const effectService = {
+    id: 'service-recommendations-effect',
+    directory: 'services/service-recommendations-effect',
+    packageSuffix: 'service-recommendations-effect',
+    portEnv: 'SERVICE_RECOMMENDATIONS_PORT',
+    port: 3030,
+    ownership: {
+        team: 'personalization-platform',
+        slack: '#personalization-platform',
+        pagerDuty: 'pd-personalization-platform',
+        runbookRef: 'runbooks/wave2/service-recommendations-effect.md',
+        adrRef: 'docs/super-app-rfc-adr/wave2/reference-topology.md#service-recommendations-effect',
+        blastRadius: {
+            tier: 'tier-2-personalization',
+            references: [
+                'docs/super-app-rfc-adr/wave2/blast-radius.md#recommendations',
+                'docs/super-app-rfc-adr/wave2/rollback.md#effect-service-lkg'
+            ]
+        }
+    }
+};
+const sharedPackages = [
+    {
+        id: 'shared-contracts',
+        directory: 'packages/shared-contracts',
+        description: 'Route, ownership, and topology contract placeholders.'
+    },
+    {
+        id: 'shared-design-tokens',
+        directory: 'packages/shared-design-tokens',
+        description: 'Design token placeholders consumed by shell and remotes.'
+    },
+    {
+        id: 'shared-effect-api',
+        directory: 'packages/shared-effect-api',
+        description: 'Shared Effect API type placeholders for services and clients.'
+    }
+];
+function normalizePath(filePath) {
+    return filePath.split(node_path.sep).join('/');
+}
+function assertSafeRelativePath(relativePath) {
+    if (0 === relativePath.length || node_path.isAbsolute(relativePath) || relativePath.split(/[\\/]+/).includes('..')) throw new Error(`Unsafe workspace template path: ${relativePath}`);
+}
+function ensureInsideRoot(root, targetPath) {
+    const relativePath = node_path.relative(root, targetPath);
+    if (relativePath.startsWith('..') || node_path.isAbsolute(relativePath)) throw new Error(`Refusing to write outside workspace root: ${targetPath}`);
+}
+function writeFile(targetDir, relativePath, content) {
+    assertSafeRelativePath(relativePath);
+    const filePath = node_path.join(targetDir, relativePath);
+    ensureInsideRoot(targetDir, filePath);
+    if (node_fs.existsSync(filePath)) throw new Error(`Refusing to overwrite generated workspace file: ${relativePath}`);
+    node_fs.mkdirSync(node_path.dirname(filePath), {
+        recursive: true
+    });
+    node_fs.writeFileSync(filePath, content, 'utf-8');
+}
+function writeJson(targetDir, relativePath, value) {
+    writeFile(targetDir, relativePath, `${JSON.stringify(value, null, 2)}\n`);
+}
+function renderTemplate(template, data) {
+    return template.replace(/\{\{(\w+)\}\}/g, (match, key)=>data[key] ?? match);
+}
+function collectTemplateFiles(dir) {
+    const files = [];
+    function collect(currentDir) {
+        for (const entry of node_fs.readdirSync(currentDir, {
+            withFileTypes: true
+        }).sort((a, b)=>a.name.localeCompare(b.name))){
+            const entryPath = node_path.join(currentDir, entry.name);
+            if (entry.isDirectory()) collect(entryPath);
+            else if (entry.isFile()) files.push(normalizePath(node_path.relative(dir, entryPath)));
+        }
+    }
+    collect(dir);
+    return files;
+}
+function hashFile(filePath) {
+    return node_crypto.createHash('sha256').update(node_fs.readFileSync(filePath)).digest('hex');
+}
+function hashTemplateTree(dir) {
+    const hash = node_crypto.createHash('sha256');
+    for (const relativePath of collectTemplateFiles(dir)){
+        hash.update(relativePath);
+        hash.update('\0');
+        hash.update(hashFile(node_path.join(dir, relativePath)));
+        hash.update('\0');
+    }
+    return hash.digest('hex');
+}
+function copyRootTemplate(targetDir, data) {
+    for (const relativePath of collectTemplateFiles(workspaceTemplateDir)){
+        const sourcePath = node_path.join(workspaceTemplateDir, relativePath);
+        const outputPath = relativePath.replace(/\.handlebars$/, '');
+        const content = relativePath.endsWith('.handlebars') ? renderTemplate(node_fs.readFileSync(sourcePath, 'utf-8'), data) : node_fs.readFileSync(sourcePath, 'utf-8');
+        writeFile(targetDir, outputPath, content);
+    }
+}
+function toPackageScope(packageName) {
+    const normalized = packageName.replace(/^@/, '').replace(/[\\/]+/g, '-').toLowerCase().replace(/[^a-z0-9._-]+/g, '-').replace(/^[._-]+|[._-]+$/g, '').replace(/-{2,}/g, '-');
+    return normalized || 'ultramodern-superapp';
+}
+function ultramodern_workspace_packageName(scope, suffix) {
+    return `@${scope}/${suffix}`;
+}
+function relativeRootFor(packageDir) {
+    return normalizePath(node_path.relative(packageDir, '.') || '.');
+}
+function resolvePackageSource(options) {
+    const strategy = options.packageSource?.strategy ?? 'workspace';
+    return {
+        strategy,
+        modernPackageVersion: 'install' === strategy ? options.packageSource?.modernPackageVersion ?? options.modernVersion : WORKSPACE_PACKAGE_VERSION,
+        registry: options.packageSource?.registry,
+        aliasScope: options.packageSource?.aliasScope,
+        aliasPackageNamePrefix: options.packageSource?.aliasPackageNamePrefix
+    };
+}
+function modernPackageVersion(packageSource) {
+    return 'install' === packageSource.strategy ? packageSource.modernPackageVersion : WORKSPACE_PACKAGE_VERSION;
+}
+function modernAliasPackageName(packageName, packageSource) {
+    if (!packageSource.aliasScope) return packageName;
+    const scope = packageSource.aliasScope.replace(/^@/, '');
+    const unscopedName = packageName.split('/').at(-1);
+    return `@${scope}/${packageSource.aliasPackageNamePrefix ?? ''}${unscopedName}`;
+}
+function modernPackageSpecifier(packageName, packageSource) {
+    if ('install' !== packageSource.strategy) return WORKSPACE_PACKAGE_VERSION;
+    if (!packageSource.aliasScope) return packageSource.modernPackageVersion;
+    return `npm:${modernAliasPackageName(packageName, packageSource)}@${packageSource.modernPackageVersion}`;
+}
+function appDependencies(scope, packageSource) {
+    return {
+        '@modern-js/plugin-tanstack': modernPackageSpecifier('@modern-js/plugin-tanstack', packageSource),
+        '@modern-js/runtime': modernPackageSpecifier('@modern-js/runtime', packageSource),
+        '@module-federation/modern-js-v3': MODULE_FEDERATION_VERSION,
+        '@module-federation/runtime': MODULE_FEDERATION_VERSION,
+        '@tanstack/react-router': TANSTACK_ROUTER_VERSION,
+        [ultramodern_workspace_packageName(scope, 'shared-contracts')]: WORKSPACE_PACKAGE_VERSION,
+        [ultramodern_workspace_packageName(scope, 'shared-design-tokens')]: WORKSPACE_PACKAGE_VERSION,
+        react: REACT_VERSION,
+        'react-dom': REACT_DOM_VERSION
+    };
+}
+function appDevDependencies(packageSource) {
+    return {
+        '@modern-js/app-tools': modernPackageSpecifier('@modern-js/app-tools', packageSource),
+        '@types/node': '^20',
+        '@types/react': '^19.1.8',
+        '@types/react-dom': '^19.1.6',
+        typescript: TYPESCRIPT_VERSION
+    };
+}
+function createRootPackageJson(scope, packageSource) {
+    return {
+        private: true,
+        name: scope,
+        version: '0.1.0',
+        scripts: {
+            dev: `pnpm --parallel --filter ${ultramodern_workspace_packageName(scope, shellApp.packageSuffix)} --filter ${ultramodern_workspace_packageName(scope, 'remote-commerce')} --filter ${ultramodern_workspace_packageName(scope, 'remote-identity')} --filter ${ultramodern_workspace_packageName(scope, 'remote-design-system')} dev`,
+            'dev:shell': `pnpm --filter ${ultramodern_workspace_packageName(scope, shellApp.packageSuffix)} dev`,
+            'dev:commerce': `pnpm --filter ${ultramodern_workspace_packageName(scope, 'remote-commerce')} dev`,
+            'dev:identity': `pnpm --filter ${ultramodern_workspace_packageName(scope, 'remote-identity')} dev`,
+            'dev:design-system': `pnpm --filter ${ultramodern_workspace_packageName(scope, 'remote-design-system')} dev`,
+            'dev:recommendations': `pnpm --filter ${ultramodern_workspace_packageName(scope, effectService.packageSuffix)} dev`,
+            build: 'pnpm -r --filter ./apps/** --filter ./services/** build',
+            typecheck: 'pnpm -r --filter ./apps/** --filter ./services/** --filter ./packages/** typecheck',
+            'ultramodern:check': "node ./scripts/validate-ultramodern-workspace.mjs",
+            check: 'pnpm ultramodern:check'
+        },
+        engines: {
+            node: '>=20',
+            pnpm: '>=10.0.0'
+        },
+        workspaces: [
+            'apps/*',
+            'apps/remotes/*',
+            'services/*',
+            'packages/*'
+        ],
+        modernjs: {
+            preset: 'presetUltramodern',
+            workspace: 'ultramodern-superapp',
+            topology: './topology/reference-topology.json',
+            ownership: './topology/ownership.json',
+            packageSource: {
+                strategy: packageSource.strategy,
+                config: './.modernjs/ultramodern-package-source.json'
+            }
+        },
+        devDependencies: {
+            '@biomejs/biome': '1.9.4',
+            typescript: TYPESCRIPT_VERSION
+        }
+    };
+}
+function createTsConfigBase(scope) {
+    return {
+        compilerOptions: {
+            target: 'ES2022',
+            lib: [
+                'DOM',
+                'DOM.Iterable',
+                'ES2022'
+            ],
+            module: 'ESNext',
+            moduleResolution: 'Bundler',
+            jsx: 'preserve',
+            strict: true,
+            noEmit: true,
+            esModuleInterop: true,
+            skipLibCheck: true,
+            resolveJsonModule: true,
+            baseUrl: '.',
+            paths: Object.fromEntries(sharedPackages.map((sharedPackage)=>[
+                    ultramodern_workspace_packageName(scope, sharedPackage.id),
+                    [
+                        `${sharedPackage.directory}/src/index.ts`
+                    ]
+                ]))
+        }
+    };
+}
+function createPackageTsConfig(packageDir, includeApi = false) {
+    const include = [
+        'src',
+        'modern.config.ts',
+        'module-federation.config.ts'
+    ];
+    if (includeApi) include.push('api', 'shared');
+    return {
+        extends: `${relativeRootFor(packageDir)}/tsconfig.base.json`,
+        compilerOptions: {
+            baseUrl: '.',
+            paths: {
+                '@/*': [
+                    './src/*'
+                ],
+                '@api/*': [
+                    './api/*'
+                ],
+                '@shared/*': [
+                    './shared/*'
+                ]
+            }
+        },
+        include
+    };
+}
+function createAppPackage(scope, app, packageSource) {
+    return {
+        private: true,
+        name: ultramodern_workspace_packageName(scope, app.packageSuffix),
+        version: '0.1.0',
+        scripts: {
+            dev: 'modern dev',
+            build: 'modern build',
+            serve: 'modern serve',
+            typecheck: 'tsgo --noEmit -p tsconfig.json'
+        },
+        modernjs: {
+            preset: 'presetUltramodern',
+            role: 'shell' === app.kind ? 'shell' : 'module-federation-remote',
+            appId: app.id,
+            topology: `${relativeRootFor(app.directory)}/topology/reference-topology.json`
+        },
+        dependencies: appDependencies(scope, packageSource),
+        devDependencies: appDevDependencies(packageSource)
+    };
+}
+function createServicePackage(scope, packageSource) {
+    return {
+        private: true,
+        name: ultramodern_workspace_packageName(scope, effectService.packageSuffix),
+        version: '0.1.0',
+        scripts: {
+            dev: 'modern dev',
+            build: 'modern build',
+            serve: 'modern serve',
+            typecheck: 'tsgo --noEmit -p tsconfig.json'
+        },
+        modernjs: {
+            preset: 'presetUltramodern',
+            role: 'effect-service',
+            appId: effectService.id,
+            topology: `${relativeRootFor(effectService.directory)}/topology/reference-topology.json`
+        },
+        dependencies: {
+            '@modern-js/runtime': modernPackageSpecifier('@modern-js/runtime', packageSource),
+            [ultramodern_workspace_packageName(scope, 'shared-effect-api')]: WORKSPACE_PACKAGE_VERSION,
+            react: REACT_VERSION,
+            'react-dom': REACT_DOM_VERSION
+        },
+        devDependencies: {
+            '@modern-js/app-tools': modernPackageSpecifier('@modern-js/app-tools', packageSource),
+            '@modern-js/plugin-bff': modernPackageSpecifier('@modern-js/plugin-bff', packageSource),
+            '@types/node': '^20',
+            '@types/react': '^19.1.8',
+            '@types/react-dom': '^19.1.6',
+            typescript: TYPESCRIPT_VERSION
+        }
+    };
+}
+function createSharedPackage(scope, id, description) {
+    return {
+        private: true,
+        name: ultramodern_workspace_packageName(scope, id),
+        version: '0.1.0',
+        description,
+        type: 'module',
+        exports: {
+            '.': './src/index.ts'
+        },
+        scripts: {
+            typecheck: 'tsgo --noEmit -p tsconfig.json'
+        },
+        devDependencies: {
+            typescript: TYPESCRIPT_VERSION
+        }
+    };
+}
+function createAppModernConfig(app) {
+    return `import { appTools, defineConfig, presetUltramodern } from '@modern-js/app-tools';
+import { tanstackRouterPlugin } from '@modern-js/plugin-tanstack';
+import { moduleFederationPlugin } from '@module-federation/modern-js-v3';
+
+const appId = '${app.id}';
+const port = Number(process.env.${app.portEnv} ?? ${app.port});
+
+export default defineConfig(
+  presetUltramodern(
+    {
+      server: {
+        port,
+        ssr: {
+          mode: 'string',
+          moduleFederationAppSSR: true,
+        },
+      },
+      output: {
+        polyfill: 'off',
+        disableTsChecker: true,
+        splitRouteChunks: false,
+      },
+      plugins: [
+        appTools(),
+        tanstackRouterPlugin(),
+        moduleFederationPlugin(),
+      ],
+    },
+    {
+      appId,
+      enableModuleFederationSSR: true,
+      enableBffRequestId: true,
+      enableTelemetryExporters: true,
+      telemetryFailLoudStartup: false,
+    },
+  ),
+);
+`;
+}
+function createShellModuleFederationConfig() {
+    return `import { createRequire } from 'node:module';
+import { createModuleFederationConfig } from '@module-federation/modern-js-v3';
+import { dependencies } from './package.json';
+
+const require = createRequire(import.meta.url);
+const runtimeVersion = (
+  require('@modern-js/runtime/package.json') as { version: string }
+).version;
+const reactVersion = (require('react/package.json') as { version: string })
+  .version;
+const reactDomVersion = (
+  require('react-dom/package.json') as { version: string }
+).version;
+
+export default createModuleFederationConfig({
+  name: '${shellApp.mfName}',
+  dts: false,
+  remotes: {
+    commerce:
+      process.env.REMOTE_COMMERCE_MF_MANIFEST ??
+      'remoteCommerce@http://localhost:3021/mf-manifest.json',
+    identity:
+      process.env.REMOTE_IDENTITY_MF_MANIFEST ??
+      'remoteIdentity@http://localhost:3022/mf-manifest.json',
+    designSystem:
+      process.env.REMOTE_DESIGN_SYSTEM_MF_MANIFEST ??
+      'remoteDesignSystem@http://localhost:3023/mf-manifest.json',
+  },
+  shared: {
+    react: {
+      singleton: true,
+      requiredVersion: reactVersion,
+      treeShaking: false,
+    },
+    'react-dom': {
+      singleton: true,
+      requiredVersion: reactDomVersion,
+      treeShaking: false,
+    },
+    '@tanstack/react-router': {
+      singleton: true,
+      requiredVersion: dependencies['@tanstack/react-router'],
+      treeShaking: false,
+    },
+    '@modern-js/runtime': {
+      singleton: true,
+      requiredVersion: runtimeVersion,
+      treeShaking: false,
+    },
+  },
+});
+`;
+}
+function createRemoteModuleFederationConfig(app) {
+    const exposes = JSON.stringify(app.exposes ?? {}, null, 4).replace(/^/gm, '  ');
+    return `import { createRequire } from 'node:module';
+import { createModuleFederationConfig } from '@module-federation/modern-js-v3';
+import { dependencies } from './package.json';
+
+const require = createRequire(import.meta.url);
+const runtimeVersion = (
+  require('@modern-js/runtime/package.json') as { version: string }
+).version;
+const reactVersion = (require('react/package.json') as { version: string })
+  .version;
+const reactDomVersion = (
+  require('react-dom/package.json') as { version: string }
+).version;
+
+export default createModuleFederationConfig({
+  name: '${app.mfName}',
+  dts: false,
+  filename: 'remoteEntry.js',
+  exposes: ${exposes},
+  shared: {
+    react: {
+      singleton: true,
+      requiredVersion: reactVersion,
+      treeShaking: false,
+    },
+    'react-dom': {
+      singleton: true,
+      requiredVersion: reactDomVersion,
+      treeShaking: false,
+    },
+    '@tanstack/react-router': {
+      singleton: true,
+      requiredVersion: dependencies['@tanstack/react-router'],
+      treeShaking: false,
+    },
+    '@modern-js/runtime': {
+      singleton: true,
+      requiredVersion: runtimeVersion,
+      treeShaking: false,
+    },
+  },
+});
+`;
+}
+function createServiceModernConfig() {
+    return `import { appTools, defineConfig, presetUltramodern } from '@modern-js/app-tools';
+import { bffPlugin } from '@modern-js/plugin-bff';
+
+const appId = '${effectService.id}';
+const port = Number(process.env.${effectService.portEnv} ?? ${effectService.port});
+
+export default defineConfig(
+  presetUltramodern(
+    {
+      server: {
+        port,
+      },
+      bff: {
+        prefix: '/recommendations-api',
+        runtimeFramework: 'effect',
+        effect: {
+          openapi: {
+            path: '/openapi.json',
+          },
+        },
+      },
+      plugins: [appTools(), bffPlugin()],
+    },
+    {
+      appId,
+      enableBffRequestId: true,
+      enableTelemetryExporters: true,
+      telemetryFailLoudStartup: false,
+    },
+  ),
+);
+`;
+}
+function createShellPage() {
+    return `const remotes = [
+  'remote-commerce',
+  'remote-identity',
+  'remote-design-system',
+];
+
+export default function ShellHome() {
+  return (
+    <main>
+      <h1>UltraModern SuperApp Shell</h1>
+      <p data-testid="ultramodern-preset">presetUltramodern workspace</p>
+      <ul>
+        {remotes.map(remote => (
+          <li key={remote}>{remote}</li>
+        ))}
+      </ul>
+    </main>
+  );
+}
+`;
+}
+function createRemotePage(app) {
+    return `export default function ${toPascalCase(app.id)}Home() {
+  return (
+    <main>
+      <h1>${app.displayName}</h1>
+      <p data-mf-role="${app.kind}">${app.domain ?? app.kind}</p>
+    </main>
+  );
+}
+`;
+}
+function createLayout(appId) {
+    return `import type { ReactNode } from 'react';
+
+export default function Layout({ children }: { children: ReactNode }) {
+  return <div data-app-id="${appId}">{children}</div>;
+}
+`;
+}
+function createRemoteEntry(app) {
+    const componentName = 'remote-identity' === app.id ? 'IdentityWidget' : 'CommerceWidget';
+    return `export { default } from './components/${componentName}';
+`;
+}
+function createRemoteWidget(app) {
+    const componentName = 'remote-identity' === app.id ? 'IdentityWidget' : 'CommerceWidget';
+    return `export default function ${componentName}() {
+  return (
+    <section data-mf-remote="${app.id}">
+      <h2>${app.displayName}</h2>
+      <p>Owns the ${app.domain} vertical route surface.</p>
+    </section>
+  );
+}
+`;
+}
+function createDesignButton() {
+    return `import { designTokens } from '../tokens';
+
+export default function Button({ label = 'Design System Button' }: { label?: string }) {
+  return (
+    <button
+      type="button"
+      style={{
+        borderRadius: designTokens.radius.control,
+        color: designTokens.color.foreground,
+      }}
+    >
+      {label}
+    </button>
+  );
+}
+`;
+}
+function createDesignTokens() {
+    return `export const designTokens = {
+  color: {
+    foreground: '#133225',
+    accent: '#2f8f68',
+  },
+  radius: {
+    control: '999px',
+  },
+} as const;
+`;
+}
+function createEffectSharedApi() {
+    return `import {
+  HttpApi,
+  HttpApiEndpoint,
+  HttpApiGroup,
+  Schema,
+} from '@modern-js/plugin-bff/effect-client';
+
+const recommendationSchema = Schema.Struct({
+  id: Schema.String,
+  title: Schema.String,
+});
+
+export const recommendationsEffectApi = HttpApi.make(
+  'RecommendationsEffectApi',
+).add(
+  HttpApiGroup.make('recommendations').add(
+    HttpApiEndpoint.get('list', '/effect/recommendations', {
+      success: Schema.Struct({
+        items: Schema.Array(recommendationSchema),
+      }),
+    }),
+  ),
+);
+`;
+}
+function createEffectServiceEntry() {
+    return `import {
+  defineEffectBff,
+  Effect,
+  HttpApiBuilder,
+  Layer,
+} from '@modern-js/plugin-bff/effect-server';
+import { recommendationsEffectApi } from '../../shared/effect/api';
+
+const recommendationsLayer = HttpApiBuilder.group(
+  recommendationsEffectApi,
+  'recommendations',
+  (handlers: any) =>
+    handlers.handle('list', () =>
+      Effect.succeed({
+        items: [
+          {
+            id: 'starter-recommendation',
+            title: 'Wire a real recommendation source here',
+          },
+        ],
+      }),
+    ),
+);
+
+const layer = HttpApiBuilder.layer(recommendationsEffectApi).pipe(
+  Layer.provide(recommendationsLayer),
+);
+
+export default defineEffectBff({
+  api: recommendationsEffectApi,
+  layer,
+});
+`;
+}
+function toPascalCase(value) {
+    return value.split(/[-_]+/).filter(Boolean).map((part)=>`${part.charAt(0).toUpperCase()}${part.slice(1)}`).join('');
+}
+function createTopology(scope) {
+    return {
+        schemaVersion: 1,
+        id: 'ultramodern-superapp-workspace-reference-topology',
+        description: 'Generated UltraModern workspace skeleton based on the reference topology shape.',
+        preset: 'presetUltramodern',
+        sourceFixture: "scripts/mv-integration-pilot/__fixtures__/reference-topology.json",
+        shell: {
+            id: shellApp.id,
+            kind: 'shell',
+            package: ultramodern_workspace_packageName(scope, shellApp.packageSuffix),
+            remoteRefs: shellApp.remoteRefs,
+            moduleFederation: {
+                role: 'host',
+                name: shellApp.mfName,
+                remotes: remoteApps.map((remote)=>({
+                        id: remote.id,
+                        name: remote.mfName,
+                        manifestUrl: `http://localhost:${remote.port}/mf-manifest.json`
+                    })),
+                ssr: true,
+                sharedContractVersion: 'mf-ssr-contract-v1'
+            },
+            ownership: shellApp.ownership
+        },
+        remotes: remoteApps.map((remote)=>({
+                id: remote.id,
+                kind: remote.kind,
+                domain: remote.domain,
+                package: ultramodern_workspace_packageName(scope, remote.packageSuffix),
+                moduleFederation: {
+                    role: 'remote',
+                    name: remote.mfName,
+                    manifestUrl: `http://localhost:${remote.port}/mf-manifest.json`,
+                    exposes: Object.keys(remote.exposes ?? {}),
+                    ssr: true,
+                    fallbackTelemetryEvent: 'modernjs:mv-runtime-parity',
+                    sharedContractVersion: 'mf-ssr-contract-v1'
+                },
+                ownership: remote.ownership
+            })),
+        effectServices: [
+            {
+                id: effectService.id,
+                kind: 'effect-service',
+                runtime: 'effect',
+                package: ultramodern_workspace_packageName(scope, effectService.packageSuffix),
+                consumedBy: [
+                    shellApp.id,
+                    'remote-commerce'
+                ],
+                bff: {
+                    prefix: '/recommendations-api',
+                    openapi: '/openapi.json'
+                },
+                ownership: effectService.ownership
+            }
+        ],
+        sharedPackages: sharedPackages.map((sharedPackage)=>({
+                id: sharedPackage.id,
+                package: ultramodern_workspace_packageName(scope, sharedPackage.id),
+                path: sharedPackage.directory,
+                description: sharedPackage.description
+            })),
+        validation: {
+            script: "scripts/validate-ultramodern-workspace.mjs",
+            commands: [
+                'pnpm ultramodern:check'
+            ]
+        }
+    };
+}
+function createOwnership(scope) {
+    return {
+        schemaVersion: 1,
+        preset: 'presetUltramodern',
+        owners: [
+            shellApp,
+            ...remoteApps,
+            {
+                id: effectService.id,
+                packageSuffix: effectService.packageSuffix,
+                directory: effectService.directory,
+                ownership: effectService.ownership
+            },
+            ...sharedPackages.map((sharedPackage)=>({
+                    id: sharedPackage.id,
+                    packageSuffix: sharedPackage.id,
+                    directory: sharedPackage.directory,
+                    ownership: {
+                        team: 'super-app-platform',
+                        slack: '#super-app-platform',
+                        pagerDuty: 'pd-super-app-platform',
+                        runbookRef: `runbooks/wave2/${sharedPackage.id}.md`,
+                        adrRef: 'docs/super-app-rfc-adr/wave2/reference-topology.md#shared-packages',
+                        blastRadius: {
+                            tier: 'tier-1-shared-contract',
+                            references: [
+                                'docs/super-app-rfc-adr/wave2/blast-radius.md#shared-packages'
+                            ]
+                        }
+                    }
+                }))
+        ].map((owner)=>({
+                id: owner.id,
+                package: ultramodern_workspace_packageName(scope, owner.packageSuffix),
+                path: owner.directory,
+                ownership: owner.ownership
+            }))
+    };
+}
+function createDevelopmentOverlay() {
+    return {
+        schemaVersion: 1,
+        environment: 'development',
+        preset: 'presetUltramodern',
+        ports: Object.fromEntries([
+            shellApp,
+            ...remoteApps
+        ].map((app)=>[
+                app.id,
+                app.port
+            ]).concat([
+            [
+                effectService.id,
+                effectService.port
+            ]
+        ])),
+        manifests: Object.fromEntries(remoteApps.map((remote)=>[
+                remote.id,
+                `http://localhost:${remote.port}/mf-manifest.json`
+            ])),
+        services: {
+            [effectService.id]: `http://localhost:${effectService.port}/recommendations-api`
+        }
+    };
+}
+function createPackageSourceMetadata(scope, packageSource) {
+    const modernPackages = {
+        packages: modernPackageNames,
+        specifier: modernPackageVersion(packageSource)
+    };
+    if (packageSource.registry) modernPackages.registry = packageSource.registry;
+    if (packageSource.aliasScope) modernPackages.aliases = Object.fromEntries(modernPackageNames.map((packageName)=>[
+            packageName,
+            modernAliasPackageName(packageName, packageSource)
+        ]));
+    return {
+        schemaVersion: 1,
+        strategy: packageSource.strategy,
+        modernPackages,
+        generatedWorkspacePackages: {
+            packages: sharedPackages.map((sharedPackage)=>ultramodern_workspace_packageName(scope, sharedPackage.id)),
+            specifier: WORKSPACE_PACKAGE_VERSION
+        },
+        validation: {
+            validator: "scripts/validate-ultramodern-workspace.mjs",
+            strategyAwareChecks: [
+                'generated-validator',
+                'contract-doctor'
+            ]
+        }
+    };
+}
+function createTemplateManifest(modernVersion, packageSource) {
+    return {
+        schemaVersion: 1,
+        template: {
+            id: 'modernjs-ultramodern-superapp-workspace',
+            version: modernVersion,
+            displayName: 'Modern.js UltraModern SuperApp Workspace',
+            description: 'Canonical shell, remotes, Effect service, shared packages, and topology skeleton.',
+            compatibilityLane: 'ultramodern-mv',
+            minimumModernVersion: modernVersion
+        },
+        source: {
+            type: 'builtin',
+            name: 'modernjs-ultramodern-superapp-workspace',
+            repositoryPath: 'packages/toolkit/create/template-workspace',
+            generator: 'packages/toolkit/create/src/ultramodern-workspace.ts'
+        },
+        integrity: {
+            checksums: [
+                {
+                    algorithm: 'sha256',
+                    value: hashTemplateTree(workspaceTemplateDir),
+                    scope: 'source-tree'
+                }
+            ],
+            provenance: {
+                kind: 'repo-local',
+                issuer: '@modern-js/create',
+                subject: 'packages/toolkit/create/template-workspace'
+            }
+        },
+        materialization: {
+            targetRoot: 'generated-project-root',
+            allowedPaths: [
+                '.modernjs/**',
+                'README.md',
+                'apps/**',
+                'packages/**',
+                'package.json',
+                'pnpm-workspace.yaml',
+                "scripts/**",
+                'services/**',
+                'topology/**',
+                'tsconfig.base.json'
+            ],
+            deniedPaths: [
+                '.git/**',
+                '.github/**',
+                '.npmrc',
+                '.yarnrc',
+                '.env',
+                '.env.*',
+                'node_modules/**',
+                'dist/**'
+            ],
+            overwritePolicy: 'deny-existing'
+        },
+        packageSource: {
+            strategy: packageSource.strategy,
+            config: '.modernjs/ultramodern-package-source.json',
+            modernPackageSpecifier: modernPackageVersion(packageSource),
+            generatedWorkspacePackageSpecifier: WORKSPACE_PACKAGE_VERSION
+        },
+        validation: {
+            schemaValidation: true,
+            sourceValidation: [
+                'source-type-supported',
+                'checksum-verified',
+                'provenance-present'
+            ],
+            materializationValidation: [
+                'path-boundary-allowlist',
+                'path-boundary-denylist',
+                'no-path-traversal',
+                'no-absolute-paths',
+                'overwrite-policy-enforced'
+            ],
+            postMaterializationValidation: [
+                'ultramodern-workspace-contract-check',
+                'template-manifest-retained'
+            ],
+            expectedCommands: [
+                "pnpm install --ignore-scripts",
+                'pnpm run ultramodern:check'
+            ]
+        }
+    };
+}
+function writeApp(targetDir, scope, app, packageSource) {
+    writeJson(targetDir, `${app.directory}/package.json`, createAppPackage(scope, app, packageSource));
+    writeJson(targetDir, `${app.directory}/tsconfig.json`, createPackageTsConfig(app.directory));
+    writeFile(targetDir, `${app.directory}/src/modern-app-env.d.ts`, "/// <reference types='@modern-js/app-tools/types' />\n");
+    writeFile(targetDir, `${app.directory}/modern.config.ts`, createAppModernConfig(app));
+    writeFile(targetDir, `${app.directory}/module-federation.config.ts`, 'shell' === app.kind ? createShellModuleFederationConfig() : createRemoteModuleFederationConfig(app));
+    writeFile(targetDir, `${app.directory}/src/routes/layout.tsx`, createLayout(app.id));
+    writeFile(targetDir, `${app.directory}/src/routes/page.tsx`, 'shell' === app.kind ? createShellPage() : createRemotePage(app));
+    if ('vertical' === app.kind) {
+        writeFile(targetDir, `${app.directory}/src/remote-entry.tsx`, createRemoteEntry(app));
+        const widgetFile = 'remote-identity' === app.id ? 'IdentityWidget.tsx' : 'CommerceWidget.tsx';
+        writeFile(targetDir, `${app.directory}/src/components/${widgetFile}`, createRemoteWidget(app));
+    }
+    if ('horizontal-design-system' === app.kind) {
+        writeFile(targetDir, `${app.directory}/src/components/Button.tsx`, createDesignButton());
+        writeFile(targetDir, `${app.directory}/src/tokens.ts`, createDesignTokens());
+    }
+}
+function writeEffectService(targetDir, scope, packageSource) {
+    writeJson(targetDir, `${effectService.directory}/package.json`, createServicePackage(scope, packageSource));
+    writeJson(targetDir, `${effectService.directory}/tsconfig.json`, createPackageTsConfig(effectService.directory, true));
+    writeFile(targetDir, `${effectService.directory}/src/modern-app-env.d.ts`, "/// <reference types='@modern-js/app-tools/types' />\n");
+    writeFile(targetDir, `${effectService.directory}/src/routes/page.tsx`, `export default function RecommendationsServiceHome() {
+  return <main>Recommendations Effect service</main>;
+}
+`);
+    writeFile(targetDir, `${effectService.directory}/modern.config.ts`, createServiceModernConfig());
+    writeFile(targetDir, `${effectService.directory}/shared/effect/api.ts`, createEffectSharedApi());
+    writeFile(targetDir, `${effectService.directory}/api/effect/index.ts`, createEffectServiceEntry());
+}
+function writeSharedPackages(targetDir, scope) {
+    for (const sharedPackage of sharedPackages){
+        writeJson(targetDir, `${sharedPackage.directory}/package.json`, createSharedPackage(scope, sharedPackage.id, sharedPackage.description));
+        writeJson(targetDir, `${sharedPackage.directory}/tsconfig.json`, {
+            extends: `${relativeRootFor(sharedPackage.directory)}/tsconfig.base.json`,
+            include: [
+                'src'
+            ]
+        });
+    }
+    writeFile(targetDir, 'packages/shared-contracts/src/index.ts', `export const ultramodernWorkspaceContract = {
+  preset: 'presetUltramodern',
+  topology: 'topology/reference-topology.json',
+  ownership: 'topology/ownership.json',
+} as const;
+`);
+    writeFile(targetDir, 'packages/shared-design-tokens/src/index.ts', `export const sharedDesignTokens = {
+  color: {
+    surface: '#f6fbf7',
+    foreground: '#133225',
+    accent: '#2f8f68',
+  },
+} as const;
+`);
+    writeFile(targetDir, 'packages/shared-effect-api/src/index.ts', `export type Recommendation = {
+  id: string;
+  title: string;
+};
+
+export const recommendationsApiContract = {
+  serviceId: '${effectService.id}',
+  basePath: '/recommendations-api/effect/recommendations',
+} as const;
+`);
+}
+function generateUltramodernWorkspace(options) {
+    const scope = toPackageScope(options.packageName);
+    const packageSource = resolvePackageSource(options);
+    node_fs.mkdirSync(options.targetDir, {
+        recursive: true
+    });
+    copyRootTemplate(options.targetDir, {
+        packageName: options.packageName,
+        packageScope: scope
+    });
+    writeJson(options.targetDir, 'package.json', createRootPackageJson(scope, packageSource));
+    writeJson(options.targetDir, 'tsconfig.base.json', createTsConfigBase(scope));
+    writeJson(options.targetDir, 'topology/reference-topology.json', createTopology(scope));
+    writeJson(options.targetDir, 'topology/ownership.json', createOwnership(scope));
+    writeJson(options.targetDir, 'topology/local-overlays/development.json', createDevelopmentOverlay());
+    writeJson(options.targetDir, '.modernjs/ultramodern-workspace-template-manifest.json', createTemplateManifest(options.modernVersion, packageSource));
+    writeJson(options.targetDir, '.modernjs/ultramodern-package-source.json', createPackageSourceMetadata(scope, packageSource));
+    writeApp(options.targetDir, scope, shellApp, packageSource);
+    for (const remote of remoteApps)writeApp(options.targetDir, scope, remote, packageSource);
+    writeEffectService(options.targetDir, scope, packageSource);
+    writeSharedPackages(options.targetDir, scope);
+}
+const src_dirname = node_path.dirname(fileURLToPath(import.meta.url));
+const templateDir = node_path.resolve(src_dirname, '..', 'template');
+const semverPattern = /^(0|[1-9][0-9]*)\.(0|[1-9][0-9]*)\.(0|[1-9][0-9]*)(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?$/;
+const semverTagPattern = /^v?(0|[1-9][0-9]*)\.(0|[1-9][0-9]*)\.(0|[1-9][0-9]*)(?:-[0-9A-Za-z.-]+)?$/;
+const sha1Pattern = /^[0-9a-f]{40}$/;
+const sha256Pattern = /^[0-9a-f]{64}$/;
+const templateIdPattern = /^[a-z0-9][a-z0-9._-]*$/;
+const packageNamePattern = /^(?:@[a-z0-9._-]+\/)?[a-z0-9._-]+$/;
+const requiredDeniedPaths = [
+    '.git/**',
+    '.github/**',
+    '.npmrc',
+    '.yarnrc',
+    '.env',
+    '.env.*',
+    'node_modules/**',
+    'dist/**'
+];
+const requiredLifecycleDeniedScripts = [
+    'preinstall',
+    'install',
+    'postinstall',
+    'prepare'
+];
+function getOptionValue(args, names) {
+    for (const name of names){
+        const prefix = `${name}=`;
+        const byEquals = args.find((arg)=>arg.startsWith(prefix));
+        if (byEquals) return byEquals.slice(prefix.length);
+        const index = args.findIndex((arg)=>arg === name);
+        if (-1 !== index && args[index + 1] && !args[index + 1].startsWith('-')) return args[index + 1];
+    }
+}
+const detectLanguage = ()=>{
+    const lang = getOptionValue(process.argv.slice(2), [
+        '--lang',
+        '-l'
+    ]);
+    if (lang) return 'zh' === lang ? 'zh' : 'en';
+    const detectedLang = getLocaleLanguage();
+    if ('zh' === detectedLang) return 'zh';
+    return 'en';
+};
+i18n.changeLanguage({
+    locale: detectLanguage()
+});
+function detectRouterFramework() {
+    const args = process.argv.slice(2);
+    if (args.includes('--tanstack')) return 'tanstack';
+    const routerValue = getOptionValue(args, [
+        '--router',
+        '-r'
+    ]);
+    if (!routerValue || 'react-router' === routerValue) return 'react-router';
+    if ('tanstack' === routerValue) return 'tanstack';
+    console.error(i18n.t(localeKeys.error.invalidRouter, {
+        router: routerValue
+    }));
+    process.exit(1);
+}
+function detectBffRuntime() {
+    const args = process.argv.slice(2);
+    const runtimeValue = getOptionValue(args, [
+        '--bff-runtime'
+    ]);
+    if (!runtimeValue) return args.includes('--bff') ? 'effect' : 'none';
+    if ('hono' === runtimeValue || 'effect' === runtimeValue) return runtimeValue;
+    console.error(i18n.t(localeKeys.error.invalidBffRuntime, {
+        runtime: runtimeValue
+    }));
+    process.exit(1);
+}
+function src_renderTemplate(template, data) {
+    const tagRegex = /\{\{(#if|#unless|\/if|\/unless)(?:\s+(\w+))?\}\}/g;
+    function renderConditionals(startIndex, expectedClose) {
+        let rendered = '';
+        let cursor = startIndex;
+        tagRegex.lastIndex = startIndex;
+        while(true){
+            const match = tagRegex.exec(template);
+            if (!match) return {
+                rendered: rendered + template.slice(cursor),
+                nextIndex: template.length
+            };
+            const [raw, tag, condition] = match;
+            const tagIndex = match.index;
+            rendered += template.slice(cursor, tagIndex);
+            cursor = tagIndex + raw.length;
+            if ('#if' === tag || '#unless' === tag) {
+                const kind = '#if' === tag ? 'if' : 'unless';
+                const innerResult = renderConditionals(cursor, kind);
+                cursor = innerResult.nextIndex;
+                tagRegex.lastIndex = cursor;
+                const conditionValue = Boolean(data[condition ?? '']);
+                const shouldInclude = 'if' === kind ? conditionValue : !conditionValue;
+                if (shouldInclude) rendered += innerResult.rendered;
+                continue;
+            }
+            if ('/if' === tag || '/unless' === tag) {
+                const kind = '/if' === tag ? 'if' : 'unless';
+                if (expectedClose === kind) return {
+                    rendered,
+                    nextIndex: cursor
+                };
+                rendered += raw;
+            }
+        }
+    }
+    let result = renderConditionals(0).rendered;
+    const varRegex = /\{\{(\w+)\}\}/g;
+    result = result.replace(varRegex, (match, key)=>{
+        const value = data[key];
+        return null != value ? String(value) : match;
+    });
+    return result;
+}
+function normalizePathForManifest(filePath) {
+    return filePath.split(node_path.sep).join('/');
+}
+function isUnsafeRelativePath(filePath) {
+    return 0 === filePath.length || node_path.isAbsolute(filePath) || filePath.startsWith('/') || /^[A-Za-z]:[\\/]/.test(filePath) || filePath.split(/[\\/]+/).includes('..');
+}
+function src_hashFile(filePath) {
+    return node_crypto.createHash('sha256').update(node_fs.readFileSync(filePath)).digest('hex');
+}
+function getTemplateFiles(dir) {
+    const files = [];
+    function collect(currentDir) {
+        const entries = node_fs.readdirSync(currentDir, {
+            withFileTypes: true
+        }).sort((a, b)=>a.name.localeCompare(b.name));
+        for (const entry of entries){
+            const entryPath = node_path.join(currentDir, entry.name);
+            if (entry.isDirectory()) collect(entryPath);
+            else if (entry.isFile()) files.push(normalizePathForManifest(node_path.relative(dir, entryPath)));
+        }
+    }
+    collect(dir);
+    return files;
+}
+function src_hashTemplateTree(dir) {
+    const hash = node_crypto.createHash('sha256');
+    for (const relativePath of getTemplateFiles(dir)){
+        const fileHash = src_hashFile(node_path.join(dir, relativePath));
+        hash.update(relativePath);
+        hash.update('\0');
+        hash.update(fileHash);
+        hash.update('\0');
+    }
+    return hash.digest('hex');
+}
+function createBuiltinTemplateManifest(version) {
+    return {
+        schemaVersion: 1,
+        template: {
+            id: 'modernjs-ultramodern-app',
+            version,
+            displayName: 'Modern.js Ultramodern App',
+            description: 'Repository-owned Modern.js application scaffold with UltraModern preset defaults.',
+            compatibilityLane: 'ultramodern-mv',
+            minimumModernVersion: version
+        },
+        source: {
+            type: 'builtin',
+            name: 'modernjs-ultramodern-app',
+            repositoryPath: 'packages/toolkit/create/template'
+        },
+        integrity: {
+            checksums: [
+                {
+                    algorithm: 'sha256',
+                    value: src_hashTemplateTree(templateDir),
+                    scope: 'source-tree'
+                }
+            ],
+            provenance: {
+                kind: 'repo-local',
+                issuer: '@modern-js/create',
+                subject: 'packages/toolkit/create/template'
+            }
+        },
+        materialization: {
+            targetRoot: 'generated-project-root',
+            allowedPaths: [
+                '.browserslistrc',
+                '.gitignore',
+                '.modernjs/**',
+                '.nvmrc',
+                'README.md',
+                'api/**',
+                'biome.json',
+                'modern.config.ts',
+                'package.json',
+                'postcss.config.mjs',
+                "scripts/**",
+                'shared/**',
+                'src/**',
+                'tailwind.config.ts',
+                'tsconfig.json'
+            ],
+            deniedPaths: requiredDeniedPaths,
+            overwritePolicy: 'deny-existing'
+        },
+        lifecyclePolicy: {
+            denyByDefault: true,
+            deniedScripts: requiredLifecycleDeniedScripts,
+            allowedScripts: [],
+            requiresExplicitOptIn: true
+        },
+        validation: {
+            schemaValidation: true,
+            sourceValidation: [
+                'source-type-supported',
+                'checksum-verified',
+                'provenance-present'
+            ],
+            materializationValidation: [
+                'path-boundary-allowlist',
+                'path-boundary-denylist',
+                'no-path-traversal',
+                'no-absolute-paths',
+                'overwrite-policy-enforced'
+            ],
+            postMaterializationValidation: [
+                'ultramodern-contract-check',
+                'dependency-install-with-lifecycle-deny',
+                'template-manifest-retained'
+            ],
+            expectedCommands: [
+                "pnpm install --ignore-scripts",
+                'pnpm run ultramodern:check'
+            ]
+        }
+    };
+}
+function assertTemplateManifest(condition, message) {
+    if (!condition) throw new Error(`Template manifest validation failed: ${message}`);
+}
+function assertSafeManifestPath(filePath, label) {
+    assertTemplateManifest(!isUnsafeRelativePath(filePath), `${label} is unsafe`);
+}
+function validateTemplateSource(source) {
+    const sourceType = source.type;
+    assertTemplateManifest('builtin' === sourceType || 'npm' === sourceType || 'git' === sourceType || 'local' === sourceType, `unsupported source type "${source.type}"`);
+    if ('builtin' === source.type) {
+        assertTemplateManifest(templateIdPattern.test(source.name), 'builtin source name must be a template id');
+        if (source.repositoryPath) assertSafeManifestPath(source.repositoryPath, 'builtin repositoryPath');
+    }
+    if ('npm' === source.type) {
+        assertTemplateManifest(packageNamePattern.test(source.packageName), 'npm packageName must be exact package metadata');
+        assertTemplateManifest(semverPattern.test(source.version), 'npm source version must be an exact semver');
+        assertTemplateManifest(sha256Pattern.test(source.tarballSha256), 'npm source tarballSha256 must be sha256 hex');
+    }
+    if ('git' === source.type) {
+        assertTemplateManifest(sha1Pattern.test(source.checkoutSha), 'git checkoutSha must pin a commit');
+        if ('sha' === source.ref.kind) assertTemplateManifest(sha1Pattern.test(source.ref.sha), 'git sha ref must be pinned to a commit');
+        else {
+            assertTemplateManifest(semverTagPattern.test(source.ref.tag), 'git tag ref must be a semver tag');
+            assertTemplateManifest(sha1Pattern.test(source.ref.tagSha), 'git tag ref must include the resolved tag sha');
+        }
+        if (source.subdirectory) assertSafeManifestPath(source.subdirectory, 'git subdirectory');
+    }
+    if ('local' === source.type) {
+        assertSafeManifestPath(source.path, 'local source path');
+        assertTemplateManifest(true !== source.allowOutsideWorkspace, 'local source cannot allow outside workspace materialization');
+    }
+}
+function validateTemplateManifest(manifest) {
+    assertTemplateManifest(1 === manifest.schemaVersion, 'schemaVersion must be 1');
+    assertTemplateManifest(templateIdPattern.test(manifest.template.id), 'template.id must be a template id');
+    assertTemplateManifest(semverPattern.test(manifest.template.version), 'template.version must be exact semver');
+    assertTemplateManifest('ultramodern-mv' === manifest.template.compatibilityLane || 'ultramodern-shell' === manifest.template.compatibilityLane || 'ultramodern-remote' === manifest.template.compatibilityLane, 'template.compatibilityLane is unsupported');
+    if (manifest.template.minimumModernVersion) assertTemplateManifest(semverPattern.test(manifest.template.minimumModernVersion), 'template.minimumModernVersion must be exact semver');
+    validateTemplateSource(manifest.source);
+    assertTemplateManifest(manifest.integrity.checksums.length > 0, 'integrity.checksums must not be empty');
+    for (const checksum of manifest.integrity.checksums){
+        assertTemplateManifest('sha256' === checksum.algorithm, 'checksum algorithm must be sha256');
+        assertTemplateManifest(sha256Pattern.test(checksum.value), 'checksum value must be sha256 hex');
+        assertTemplateManifest('manifest' === checksum.scope || 'source-archive' === checksum.scope || 'source-tree' === checksum.scope || 'lockfile' === checksum.scope, 'checksum scope is unsupported');
+    }
+    assertTemplateManifest(manifest.integrity.provenance.kind && manifest.integrity.provenance.issuer && manifest.integrity.provenance.subject, 'provenance kind, issuer, and subject are required');
+    if (manifest.integrity.lockfile) {
+        assertSafeManifestPath(manifest.integrity.lockfile.path, 'lockfile path');
+        assertTemplateManifest(sha256Pattern.test(manifest.integrity.lockfile.sha256), 'lockfile sha256 must be sha256 hex');
+    }
+    assertTemplateManifest('generated-project-root' === manifest.materialization.targetRoot || 'workspace-package-root' === manifest.materialization.targetRoot, 'materialization.targetRoot is unsupported');
+    assertTemplateManifest(manifest.materialization.allowedPaths.length > 0, 'materialization.allowedPaths must not be empty');
+    for (const allowedPath of manifest.materialization.allowedPaths)assertSafeManifestPath(allowedPath.replace(/\/\*\*$/, '/placeholder'), 'allowed path');
+    for (const deniedPath of manifest.materialization.deniedPaths)assertSafeManifestPath(deniedPath.replace(/\/\*\*$/, '/placeholder'), 'denied path');
+    for (const deniedPath of requiredDeniedPaths)assertTemplateManifest(manifest.materialization.deniedPaths.includes(deniedPath), `materialization.deniedPaths must include ${deniedPath}`);
+    assertTemplateManifest(!manifest.materialization.overwritePolicy || 'deny-existing' === manifest.materialization.overwritePolicy || 'allow-generated-only' === manifest.materialization.overwritePolicy, 'materialization.overwritePolicy is unsupported');
+    assertTemplateManifest(true === manifest.lifecyclePolicy.denyByDefault, 'lifecyclePolicy.denyByDefault must be true');
+    for (const scriptName of requiredLifecycleDeniedScripts)assertTemplateManifest(manifest.lifecyclePolicy.deniedScripts.includes(scriptName), `lifecyclePolicy.deniedScripts must include ${scriptName}`);
+    assertTemplateManifest(0 === manifest.lifecyclePolicy.allowedScripts.length, 'lifecyclePolicy.allowedScripts must be empty for builtin materialization');
+    assertTemplateManifest(true === manifest.validation.schemaValidation, 'validation.schemaValidation must be true');
+    for (const token of [
+        'source-type-supported',
+        'checksum-verified',
+        'provenance-present'
+    ])assertTemplateManifest(manifest.validation.sourceValidation.includes(token), `validation.sourceValidation must include ${token}`);
+    for (const token of [
+        'path-boundary-allowlist',
+        'path-boundary-denylist',
+        'no-path-traversal',
+        'no-absolute-paths',
+        'overwrite-policy-enforced'
+    ])assertTemplateManifest(manifest.validation.materializationValidation.includes(token), `validation.materializationValidation must include ${token}`);
+    assertTemplateManifest(manifest.validation.postMaterializationValidation.includes('template-manifest-retained'), 'validation.postMaterializationValidation must retain manifest evidence');
+}
+function matchesManifestPattern(pattern, relativePath) {
+    if (pattern.endsWith('/**')) {
+        const prefix = pattern.slice(0, -3);
+        return relativePath === prefix || relativePath.startsWith(`${prefix}/`);
+    }
+    if (pattern.endsWith('.*')) {
+        const prefix = pattern.slice(0, -1);
+        return relativePath.startsWith(prefix);
+    }
+    return relativePath === pattern;
+}
+function canMaterializePath(manifest, relativePath) {
+    if (isUnsafeRelativePath(relativePath)) throw new Error(`Unsafe template path rejected: ${relativePath}`);
+    if (manifest.materialization.deniedPaths.some((pattern)=>matchesManifestPattern(pattern, relativePath))) return false;
+    if (!manifest.materialization.allowedPaths.some((pattern)=>matchesManifestPattern(pattern, relativePath))) throw new Error(`Template path is not allowed by manifest: ${relativePath}`);
+    return true;
+}
+function writeTemplateManifestEvidence(targetDir, manifest) {
+    const evidencePath = node_path.join(targetDir, '.modernjs', 'mv-template-manifest.json');
+    const evidenceRelativePath = normalizePathForManifest(node_path.relative(targetDir, evidencePath));
+    if (!canMaterializePath(manifest, evidenceRelativePath)) throw new Error('Template manifest evidence path is denied by manifest');
+    node_fs.mkdirSync(node_path.dirname(evidencePath), {
+        recursive: true
+    });
+    node_fs.writeFileSync(evidencePath, `${JSON.stringify(manifest, null, 2)}\n`);
+}
+function showVersion() {
+    const createPackageJson = node_path.resolve(src_dirname, '..', 'package.json');
+    const createPackage = JSON.parse(node_fs.readFileSync(createPackageJson, 'utf-8'));
+    const version = createPackage.version || 'unknown';
+    console.log(i18n.t(localeKeys.version.message, {
+        version
+    }));
+    process.exit(0);
+}
+function showHelp() {
+    console.log(i18n.t(localeKeys.help.title));
+    console.log(i18n.t(localeKeys.help.description));
+    console.log('');
+    console.log(i18n.t(localeKeys.help.usage));
+    console.log(i18n.t(localeKeys.help.usageExample));
+    console.log('');
+    console.log(i18n.t(localeKeys.help.options));
+    console.log(i18n.t(localeKeys.help.optionHelp));
+    console.log(i18n.t(localeKeys.help.optionVersion));
+    console.log(i18n.t(localeKeys.help.optionLang));
+    console.log(i18n.t(localeKeys.help.optionRouter));
+    if (localeKeys.help.optionBff) console.log(i18n.t(localeKeys.help.optionBff));
+    if (localeKeys.help.optionBffRuntime) console.log(i18n.t(localeKeys.help.optionBffRuntime));
+    if (localeKeys.help.optionTailwind) console.log(i18n.t(localeKeys.help.optionTailwind));
+    if (localeKeys.help.optionWorkspace) console.log(i18n.t(localeKeys.help.optionWorkspace));
+    if (localeKeys.help.optionUltramodernWorkspace) console.log(i18n.t(localeKeys.help.optionUltramodernWorkspace));
+    if (localeKeys.help.optionUltramodernPackageSource) console.log(i18n.t(localeKeys.help.optionUltramodernPackageSource));
+    if (localeKeys.help.optionUltramodernPackageScope) console.log(i18n.t(localeKeys.help.optionUltramodernPackageScope));
+    if (localeKeys.help.optionUltramodernPackageNamePrefix) console.log(i18n.t(localeKeys.help.optionUltramodernPackageNamePrefix));
+    console.log(i18n.t(localeKeys.help.optionSub));
+    console.log('');
+    console.log(i18n.t(localeKeys.help.examples));
+    console.log(i18n.t(localeKeys.help.example1));
+    console.log(i18n.t(localeKeys.help.example2));
+    console.log(i18n.t(localeKeys.help.example3));
+    if (localeKeys.help.example4) console.log(i18n.t(localeKeys.help.example4));
+    if (localeKeys.help.example5) console.log(i18n.t(localeKeys.help.example5));
+    if (localeKeys.help.example6) console.log(i18n.t(localeKeys.help.example6));
+    if (localeKeys.help.example7) console.log(i18n.t(localeKeys.help.example7));
+    if (localeKeys.help.example8) console.log(i18n.t(localeKeys.help.example8));
+    if (localeKeys.help.example9) console.log(i18n.t(localeKeys.help.example9));
+    if (localeKeys.help.example10) console.log(i18n.t(localeKeys.help.example10));
+    console.log('');
+    console.log(i18n.t(localeKeys.help.moreInfo));
+    console.log('');
+    process.exit(0);
+}
+function promptInput(question) {
+    const rl = node_readline.createInterface({
+        input: process.stdin,
+        output: process.stdout
+    });
+    return new Promise((resolve)=>{
+        rl.question(question, (answer)=>{
+            rl.close();
+            resolve(answer.trim());
+        });
+    });
+}
+function detectSubprojectFlag() {
+    const args = process.argv.slice(2);
+    if (args.includes('--sub') || args.includes('-s')) return true;
+    if (args.includes('--no-sub')) return false;
+    return null;
+}
+function detectTailwindFlag() {
+    const args = process.argv.slice(2);
+    return args.includes('--tailwind');
+}
+function detectWorkspaceProtocolFlag() {
+    const args = process.argv.slice(2);
+    return args.includes('--workspace');
+}
+function detectUltramodernWorkspaceFlag() {
+    const args = process.argv.slice(2);
+    return args.includes(ULTRAMODERN_WORKSPACE_FLAG);
+}
+function detectUltramodernPackageSource(args, modernVersion) {
+    const strategy = getOptionValue(args, [
+        '--ultramodern-package-source'
+    ]) ?? 'workspace';
+    if ('workspace' !== strategy && 'install' !== strategy) {
+        console.error('--ultramodern-package-source must be "workspace" or "install"');
+        process.exit(1);
+    }
+    return {
+        strategy,
+        modernPackageVersion: getOptionValue(args, [
+            '--ultramodern-package-version'
+        ]) ?? modernVersion,
+        registry: getOptionValue(args, [
+            '--ultramodern-package-registry'
+        ]),
+        aliasScope: getOptionValue(args, [
+            '--ultramodern-package-scope'
+        ]),
+        aliasPackageNamePrefix: getOptionValue(args, [
+            '--ultramodern-package-name-prefix'
+        ]) ?? 'modern-js-'
+    };
+}
+function isDirectoryEmpty(dirPath) {
+    if (!node_fs.existsSync(dirPath)) return false;
+    try {
+        const files = node_fs.readdirSync(dirPath);
+        return 0 === files.length;
+    } catch  {
+        return false;
+    }
+}
+async function getProjectName() {
+    const args = process.argv.slice(2);
+    const optionWithValue = new Set([
+        '--lang',
+        '-l',
+        '--router',
+        '-r',
+        '--bff-runtime',
+        '--ultramodern-package-source',
+        '--ultramodern-package-version',
+        '--ultramodern-package-registry',
+        '--ultramodern-package-scope',
+        '--ultramodern-package-name-prefix'
+    ]);
+    const optionWithoutValue = new Set([
+        '--help',
+        '-h',
+        '--version',
+        '-v',
+        '--sub',
+        '-s',
+        '--no-sub',
+        '--tanstack',
+        '--bff',
+        '--tailwind',
+        '--workspace',
+        ULTRAMODERN_WORKSPACE_FLAG
+    ]);
+    const positionalArgs = [];
+    for(let i = 0; i < args.length; i++){
+        const arg = args[i];
+        if (!optionWithoutValue.has(arg)) {
+            if (optionWithValue.has(arg)) {
+                i += 1;
+                continue;
+            }
+            if (!(arg.startsWith('--lang=') || arg.startsWith('--router=') || arg.startsWith('--bff-runtime=') || arg.startsWith('--ultramodern-package-source=') || arg.startsWith('--ultramodern-package-version=') || arg.startsWith('--ultramodern-package-registry=') || arg.startsWith('--ultramodern-package-scope=') || arg.startsWith('--ultramodern-package-name-prefix='))) positionalArgs.push(arg);
+        }
+    }
+    const projectNameArg = positionalArgs[0];
+    if (projectNameArg) return {
+        name: projectNameArg,
+        useCurrentDir: false
+    };
+    const currentDir = process.cwd();
+    if (isDirectoryEmpty(currentDir)) return {
+        name: node_path.basename(currentDir),
+        useCurrentDir: true
+    };
+    const projectName = await promptInput(i18n.t(localeKeys.prompt.projectName));
+    if (!projectName) {
+        console.error(i18n.t(localeKeys.error.projectNameEmpty));
+        process.exit(1);
+    }
+    return {
+        name: projectName,
+        useCurrentDir: false
+    };
+}
+async function main() {
+    const args = process.argv.slice(2);
+    if (args.includes('--help') || args.includes('-h')) return void showHelp();
+    if (args.includes('--version') || args.includes('-v')) return void showVersion();
+    console.log(`\n${i18n.t(localeKeys.message.welcome)}\n`);
+    const { name: projectName, useCurrentDir } = await getProjectName();
+    const targetDir = useCurrentDir ? process.cwd() : node_path.isAbsolute(projectName) ? projectName : node_path.resolve(process.cwd(), projectName);
+    const generatedPackageName = useCurrentDir || node_path.isAbsolute(projectName) ? node_path.basename(targetDir) : projectName;
+    if (node_fs.existsSync(targetDir)) {
+        const files = node_fs.readdirSync(targetDir);
+        if (files.length > 0) {
+            console.error(i18n.t(localeKeys.error.directoryExists, {
+                projectName
+            }));
+            process.exit(1);
+        }
+    }
+    const createPackageJson = node_path.resolve(src_dirname, '..', 'package.json');
+    const createPackage = JSON.parse(node_fs.readFileSync(createPackageJson, 'utf-8'));
+    const version = createPackage.version || 'latest';
+    const generateWorkspace = detectUltramodernWorkspaceFlag();
+    if (generateWorkspace) {
+        generateUltramodernWorkspace({
+            targetDir,
+            packageName: generatedPackageName,
+            modernVersion: version,
+            packageSource: detectUltramodernPackageSource(args, version)
+        });
+        const dim = '\x1b[2m\x1b[3m';
+        const reset = '\x1b[0m';
+        console.log(`${i18n.t(localeKeys.message.success)}\n`);
+        console.log(i18n.t(localeKeys.message.nextSteps));
+        if (!useCurrentDir) console.log(`${dim}   ${i18n.t(localeKeys.message.step1, {
+            projectName
+        })}${reset}`);
+        console.log(`${dim}   ${i18n.t(localeKeys.message.step2)}${reset}`);
+        console.log(`${dim}   pnpm ultramodern:check${reset}`);
+        console.log(`${dim}   ${i18n.t(localeKeys.message.step3)}${reset}\n`);
+        return;
+    }
+    const subprojectFlag = detectSubprojectFlag();
+    const isSubproject = true === subprojectFlag;
+    const routerFramework = detectRouterFramework();
+    const bffRuntime = detectBffRuntime();
+    const enableTailwind = detectTailwindFlag();
+    const useWorkspaceProtocol = detectWorkspaceProtocolFlag();
+    const dependencyVersion = useWorkspaceProtocol ? 'workspace:*' : version;
+    const templateManifest = createBuiltinTemplateManifest(version);
+    validateTemplateManifest(templateManifest);
+    copyTemplate(templateDir, targetDir, {
+        packageName: generatedPackageName,
+        version: dependencyVersion,
+        isSubproject,
+        routerFramework,
+        bffRuntime,
+        enableTailwind,
+        templateManifest
+    });
+    const targetPackageJson = node_path.join(targetDir, 'package.json');
+    const packageJson = JSON.parse(node_fs.readFileSync(targetPackageJson, 'utf-8'));
+    packageJson.name = generatedPackageName;
+    if (isSubproject) {
+        delete packageJson['lint-staged'];
+        delete packageJson['simple-git-hooks'];
+        if (packageJson.scripts) {
+            delete packageJson.scripts.prepare;
+            delete packageJson.scripts.lint;
+        }
+        if (packageJson.devDependencies) {
+            delete packageJson.devDependencies['lint-staged'];
+            delete packageJson.devDependencies['simple-git-hooks'];
+            delete packageJson.devDependencies['@biomejs/biome'];
+        }
+    }
+    node_fs.writeFileSync(targetPackageJson, `${JSON.stringify(packageJson, null, 2)}\n`);
+    writeTemplateManifestEvidence(targetDir, templateManifest);
+    const dim = '\x1b[2m\x1b[3m';
+    const reset = '\x1b[0m';
+    console.log(`${i18n.t(localeKeys.message.success)}\n`);
+    console.log(i18n.t(localeKeys.message.nextSteps));
+    if (!useCurrentDir) console.log(`${dim}   ${i18n.t(localeKeys.message.step1, {
+        projectName
+    })}${reset}`);
+    console.log(`${dim}   ${i18n.t(localeKeys.message.step2)}${reset}`);
+    console.log(`${dim}   ${i18n.t(localeKeys.message.step3)}${reset}\n`);
+}
+function copyTemplate(src, dest, options) {
+    node_fs.mkdirSync(dest, {
+        recursive: true
+    });
+    const excludeInSubproject = [
+        '.gitignore.handlebars',
+        'biome.json',
+        '.npmrc',
+        '.nvmrc'
+    ];
+    function copyRecursive(srcDir, destDir) {
+        const entries = node_fs.readdirSync(srcDir, {
+            withFileTypes: true
+        });
+        for (const entry of entries){
+            if (options.isSubproject && excludeInSubproject.includes(entry.name)) continue;
+            const srcPath = node_path.join(srcDir, entry.name);
+            let destPath = node_path.join(destDir, entry.name);
+            const sourceRelativePath = normalizePathForManifest(node_path.relative(src, srcPath));
+            const finalRelativePath = normalizePathForManifest(sourceRelativePath.replace(/\.handlebars$/, ''));
+            if (!(!canMaterializePath(options.templateManifest, finalRelativePath) || entry.isDirectory() && options.templateManifest.materialization.deniedPaths.some((pattern)=>matchesManifestPattern(pattern, finalRelativePath)))) if (entry.isDirectory()) {
+                node_fs.mkdirSync(destPath, {
+                    recursive: true
+                });
+                copyRecursive(srcPath, destPath);
+            } else if (entry.name.endsWith('.handlebars')) {
+                const templateContent = node_fs.readFileSync(srcPath, 'utf-8');
+                const rendered = src_renderTemplate(templateContent, {
+                    packageName: options.packageName,
+                    version: options.version,
+                    isSubproject: options.isSubproject,
+                    isTanstackRouter: 'tanstack' === options.routerFramework,
+                    enableBff: 'none' !== options.bffRuntime,
+                    useEffectBff: 'effect' === options.bffRuntime,
+                    useHonoBff: 'hono' === options.bffRuntime,
+                    bffRuntime: options.bffRuntime,
+                    enableTailwind: options.enableTailwind,
+                    routerImportPath: 'tanstack' === options.routerFramework ? 'tanstack-router' : 'router'
+                });
+                if (0 === rendered.trim().length) continue;
+                destPath = destPath.replace(/\.handlebars$/, '');
+                if ('deny-existing' === options.templateManifest.materialization.overwritePolicy && node_fs.existsSync(destPath)) throw new Error(`Template refused to overwrite existing file: ${finalRelativePath}`);
+                node_fs.writeFileSync(destPath, rendered, 'utf-8');
+            } else {
+                if ('deny-existing' === options.templateManifest.materialization.overwritePolicy && node_fs.existsSync(destPath)) throw new Error(`Template refused to overwrite existing file: ${finalRelativePath}`);
+                node_fs.copyFileSync(srcPath, destPath);
+            }
+        }
+    }
+    copyRecursive(src, dest);
+}
+main().catch((error)=>{
+    console.error(i18n.t(localeKeys.error.createFailed), error);
+    process.exit(1);
+});