@bleedingdev/modern-js-create 3.2.0-ultramodern.11 → 3.2.0-ultramodern.111

package/dist/esm-node/index.js

@@ -0,0 +1,1005 @@
+import "node:module";
+import { execFileSync } from "node:child_process";
+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 { getLocaleLanguage } from "@modern-js/i18n-utils/language-detector";
+import { i18n, localeKeys } from "./locale/index.js";
+import { BLEEDINGDEV_CREATE_PACKAGE, BLEEDINGDEV_FRAMEWORK_VERSION_ENV, BLEEDINGDEV_PACKAGE_NAME_PREFIX, BLEEDINGDEV_PACKAGE_SCOPE, ULTRAMODERN_SINGLE_APP_MODERN_PACKAGES, WORKSPACE_PACKAGE_VERSION, createModernPackagesMetadata, modernPackageSpecifier } from "./ultramodern-package-source.js";
+import { ULTRAMODERN_WORKSPACE_FLAG, addUltramodernVertical, generateUltramodernWorkspace } from "./ultramodern-workspace.js";
+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 TANSTACK_ROUTER_VERSION = '1.170.15';
+const TAILWIND_VERSION = '4.3.0';
+const TAILWIND_POSTCSS_VERSION = '4.3.0';
+const PNPM_VERSION = '11.5.0';
+const I18NEXT_VERSION = '26.3.1';
+const REACT_VERSION = '^19.2.7';
+const REACT_DOM_VERSION = '^19.2.7';
+const REACT_I18NEXT_VERSION = '17.0.8';
+const EFFECT_TSGO_VERSION = '0.14.0';
+const TYPESCRIPT_NATIVE_PREVIEW_VERSION = '7.0.0-dev.20260606.1';
+const HAPPY_DOM_VERSION = '^20.10.1';
+const RSTEST_CORE_VERSION = '0.10.3';
+const OXFMT_VERSION = '0.53.0';
+const OXLINT_VERSION = '1.68.0';
+const POSTCSS_VERSION = '^8.5.15';
+const ULTRACITE_VERSION = '7.8.1';
+const TYPES_REACT_VERSION = '^19.2.17';
+const TYPES_REACT_DOM_VERSION = '^19.2.3';
+const requiredDeniedPaths = [
+    '.git/**',
+    '.npmrc',
+    '.yarnrc',
+    '.env',
+    '.env.*',
+    'node_modules/**',
+    'dist/**'
+];
+const requiredLifecycleDeniedScripts = [
+    'preinstall',
+    'install',
+    'prepare'
+];
+const requiredLifecycleAllowedScripts = [
+    'postinstall'
+];
+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 || 'tanstack' === routerValue) return 'tanstack';
+    if ('react-router' === routerValue) return 'react-router';
+    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 'effect';
+    if ('hono' === runtimeValue || 'effect' === runtimeValue) return runtimeValue;
+    console.error(i18n.t(localeKeys.error.invalidBffRuntime, {
+        runtime: runtimeValue
+    }));
+    process.exit(1);
+}
+function 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, rightTrim] = 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) {
+                    let nextIndex = cursor;
+                    if ('~' === rightTrim) {
+                        const trailingWhitespace = /^\s*/u.exec(template.slice(nextIndex));
+                        nextIndex += trailingWhitespace?.[0].length ?? 0;
+                    }
+                    return {
+                        rendered,
+                        nextIndex
+                    };
+                }
+                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 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 hashTemplateTree(dir) {
+    const hash = node_crypto.createHash('sha256');
+    for (const relativePath of getTemplateFiles(dir)){
+        const fileHash = 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: hashTemplateTree(templateDir),
+                    scope: 'source-tree'
+                }
+            ],
+            provenance: {
+                kind: 'repo-local',
+                issuer: '@modern-js/create',
+                subject: 'packages/toolkit/create/template'
+            }
+        },
+        materialization: {
+            targetRoot: 'generated-project-root',
+            allowedPaths: [
+                '.agents/**',
+                '.browserslistrc',
+                '.codex/**',
+                '.github/**',
+                '.gitignore',
+                '.mise.toml',
+                '.modernjs/**',
+                '.nvmrc',
+                'AGENTS.md',
+                'README.md',
+                'api/**',
+                'config/**',
+                'lefthook.yml',
+                'modern.config.ts',
+                'oxfmt.config.ts',
+                'oxlint.config.ts',
+                'package.json',
+                'pnpm-workspace.yaml',
+                'postcss.config.mjs',
+                'rstest.config.mts',
+                "scripts/**",
+                'shared/**',
+                'src/**',
+                'tailwind.config.ts',
+                'tests/**',
+                'tsconfig.json'
+            ],
+            deniedPaths: requiredDeniedPaths,
+            overwritePolicy: 'deny-existing'
+        },
+        lifecyclePolicy: {
+            denyByDefault: true,
+            deniedScripts: requiredLifecycleDeniedScripts,
+            allowedScripts: requiredLifecycleAllowedScripts,
+            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',
+                'agent-skill-postinstall-allowed',
+                'github-workflow-security-enforced',
+                'package-source-retained',
+                'pnpm-11-policy-enforced',
+                'rstest-smoke-tests',
+                'template-manifest-retained'
+            ],
+            expectedCommands: [
+                'mise install',
+                'pnpm install',
+                'pnpm test',
+                '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(JSON.stringify(manifest.lifecyclePolicy.allowedScripts) === JSON.stringify(requiredLifecycleAllowedScripts), 'lifecyclePolicy.allowedScripts must only allow generated postinstall');
+    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 readCreatePackageJson() {
+    const createPackageJson = node_path.resolve(src_dirname, '..', 'package.json');
+    return JSON.parse(node_fs.readFileSync(createPackageJson, 'utf-8'));
+}
+function isBleedingDevCreatePackage(createPackage) {
+    return createPackage.name === BLEEDINGDEV_CREATE_PACKAGE;
+}
+function getBleedingDevFrameworkVersion(createPackage, fallbackVersion) {
+    const frameworkVersion = createPackage.ultramodern?.frameworkVersion;
+    return 'string' == typeof frameworkVersion && frameworkVersion.length > 0 ? frameworkVersion : fallbackVersion;
+}
+function showVersion() {
+    const createPackage = readCreatePackageJson();
+    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));
+    if (localeKeys.help.optionVertical) console.log(i18n.t(localeKeys.help.optionVertical));
+    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));
+    if (localeKeys.help.example11) console.log(i18n.t(localeKeys.help.example11));
+    if (localeKeys.help.example12) console.log(i18n.t(localeKeys.help.example12));
+    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('--no-tailwind');
+}
+function detectExplicitTailwindFlag() {
+    const args = process.argv.slice(2);
+    if (args.includes('--no-tailwind')) return false;
+    if (args.includes('--tailwind')) return true;
+}
+function detectWorkspaceProtocolFlag() {
+    const args = process.argv.slice(2);
+    return args.includes('--workspace');
+}
+function detectVerticalFlag() {
+    const args = process.argv.slice(2);
+    if (args.some((arg)=>arg.startsWith('--vertical='))) {
+        console.error('--vertical does not accept a value. Use: create <name> --vertical');
+        process.exit(1);
+    }
+    return args.includes('--vertical');
+}
+function detectUltramodernWorkspaceFlag() {
+    const args = process.argv.slice(2);
+    return args.includes(ULTRAMODERN_WORKSPACE_FLAG);
+}
+function detectUltramodernPackageSource(args, defaultPackageVersion, createPackage) {
+    const bleedingDevDefaults = isBleedingDevCreatePackage(createPackage);
+    const strategy = getOptionValue(args, [
+        '--ultramodern-package-source'
+    ]) ?? (bleedingDevDefaults ? 'install' : 'workspace');
+    if ('workspace' !== strategy && 'install' !== strategy) {
+        console.error('--ultramodern-package-source must be "workspace" or "install"');
+        process.exit(1);
+    }
+    const packageSourceStrategy = strategy;
+    const explicitRegistry = getOptionValue(args, [
+        '--ultramodern-package-registry'
+    ]);
+    const aliasScope = getOptionValue(args, [
+        '--ultramodern-package-scope'
+    ]) ?? (bleedingDevDefaults && 'install' === packageSourceStrategy && !explicitRegistry ? BLEEDINGDEV_PACKAGE_SCOPE : void 0);
+    return {
+        strategy: packageSourceStrategy,
+        modernPackageVersion: getOptionValue(args, [
+            '--ultramodern-package-version'
+        ]) ?? defaultPackageVersion,
+        registry: explicitRegistry,
+        aliasScope,
+        aliasPackageNamePrefix: getOptionValue(args, [
+            '--ultramodern-package-name-prefix'
+        ]) ?? (aliasScope ? BLEEDINGDEV_PACKAGE_NAME_PREFIX : void 0)
+    };
+}
+function hasExplicitUltramodernPackageSource(args, value) {
+    const configuredValue = getOptionValue(args, [
+        '--ultramodern-package-source'
+    ]);
+    return value ? configuredValue === value : void 0 !== configuredValue;
+}
+function readBleedingDevFrameworkVersionFromRegistry() {
+    const envVersion = process.env[BLEEDINGDEV_FRAMEWORK_VERSION_ENV]?.trim();
+    if (envVersion) {
+        if (!semverPattern.test(envVersion)) {
+            console.error(`${BLEEDINGDEV_FRAMEWORK_VERSION_ENV} must be a valid semver version`);
+            process.exit(1);
+        }
+        return envVersion;
+    }
+    try {
+        const rawVersion = runSetupCommand('npm', [
+            'view',
+            `${BLEEDINGDEV_CREATE_PACKAGE}@latest`,
+            'ultramodern.frameworkVersion',
+            '--json'
+        ]).trim();
+        const version = JSON.parse(rawVersion);
+        if ('string' == typeof version && semverPattern.test(version)) return version;
+    } catch  {}
+    console.error([
+        `Could not resolve ${BLEEDINGDEV_CREATE_PACKAGE}@latest ultramodern.frameworkVersion.`,
+        'Pass --workspace to use local workspace protocol dependencies,',
+        'or pass --ultramodern-package-version with the exact BleedingDev framework cohort.'
+    ].join(' '));
+    process.exit(1);
+}
+function resolveInstallBackedPackageSource(args, createPackage, packageSource) {
+    const explicitVersion = getOptionValue(args, [
+        '--ultramodern-package-version'
+    ]);
+    const explicitRegistry = getOptionValue(args, [
+        '--ultramodern-package-registry'
+    ]);
+    const aliasScope = getOptionValue(args, [
+        '--ultramodern-package-scope'
+    ]) ?? packageSource.aliasScope ?? (explicitRegistry ? void 0 : BLEEDINGDEV_PACKAGE_SCOPE);
+    return {
+        ...packageSource,
+        strategy: 'install',
+        modernPackageVersion: explicitVersion ?? (isBleedingDevCreatePackage(createPackage) ? packageSource.modernPackageVersion : readBleedingDevFrameworkVersionFromRegistry()),
+        aliasScope,
+        aliasPackageNamePrefix: getOptionValue(args, [
+            '--ultramodern-package-name-prefix'
+        ]) ?? packageSource.aliasPackageNamePrefix ?? (aliasScope ? BLEEDINGDEV_PACKAGE_NAME_PREFIX : void 0)
+    };
+}
+function resolveSingleAppPackageSource(args, createPackage, packageSource, useWorkspaceProtocol) {
+    if (useWorkspaceProtocol) return {
+        ...packageSource,
+        strategy: 'workspace',
+        modernPackageVersion: WORKSPACE_PACKAGE_VERSION
+    };
+    return resolveInstallBackedPackageSource(args, createPackage, packageSource);
+}
+function resolveWorkspacePackageSource(args, createPackage, packageSource) {
+    if (hasExplicitUltramodernPackageSource(args, 'workspace')) return {
+        ...packageSource,
+        strategy: 'workspace',
+        modernPackageVersion: WORKSPACE_PACKAGE_VERSION
+    };
+    return resolveInstallBackedPackageSource(args, createPackage, packageSource);
+}
+function createSingleAppPackageSourceEvidence(packageSource) {
+    return {
+        schemaVersion: 1,
+        preset: 'presetUltramodern',
+        strategy: packageSource.strategy,
+        modernPackages: createModernPackagesMetadata(ULTRAMODERN_SINGLE_APP_MODERN_PACKAGES, packageSource, {
+            includeAliases: 'install' === packageSource.strategy
+        })
+    };
+}
+function writeSingleAppPackageSourceEvidence(targetDir, packageSource) {
+    const evidencePath = node_path.join(targetDir, '.modernjs', 'ultramodern-package-source.json');
+    node_fs.mkdirSync(node_path.dirname(evidencePath), {
+        recursive: true
+    });
+    node_fs.writeFileSync(evidencePath, `${JSON.stringify(createSingleAppPackageSourceEvidence(packageSource), null, 2)}\n`);
+}
+function runSetupCommand(command, args, options = {}) {
+    return execFileSync(command, args, {
+        cwd: options.cwd,
+        encoding: 'utf-8',
+        stdio: options.stdio ?? [
+            'ignore',
+            'pipe',
+            'pipe'
+        ]
+    });
+}
+function commandExists(command) {
+    try {
+        runSetupCommand(command, [
+            '--version'
+        ], {
+            stdio: 'ignore'
+        });
+        return true;
+    } catch  {
+        return false;
+    }
+}
+function installGitForGeneratedProject() {
+    if (commandExists('git')) return;
+    const runShell = (script)=>runSetupCommand('sh', [
+            '-lc',
+            script
+        ], {
+            stdio: 'inherit'
+        });
+    const sudo = 'function' == typeof process.getuid && 0 === process.getuid() ? '' : 'sudo ';
+    if (commandExists('brew')) runSetupCommand('brew', [
+        'install',
+        'git'
+    ], {
+        stdio: 'inherit'
+    });
+    else if ('linux' === process.platform && commandExists('apt-get')) runShell(`${sudo}apt-get update && ${sudo}apt-get install -y git`);
+    else if ('linux' === process.platform && commandExists('dnf')) runShell(`${sudo}dnf install -y git`);
+    else if ('linux' === process.platform && commandExists('yum')) runShell(`${sudo}yum install -y git`);
+    else if ('linux' === process.platform && commandExists('apk')) runShell('apk add --no-cache git');
+    if (!commandExists('git')) throw new Error('Git is required for UltraModern setup. Install git and rerun create, or run pnpm skills:install after installing git.');
+}
+function isInsideGitWorkTree(targetDir) {
+    try {
+        return 'true' === runSetupCommand('git', [
+            'rev-parse',
+            '--is-inside-work-tree'
+        ], {
+            cwd: targetDir
+        }).trim();
+    } catch  {
+        return false;
+    }
+}
+function initializeGeneratedGitRepository(targetDir) {
+    installGitForGeneratedProject();
+    if (isInsideGitWorkTree(targetDir)) return;
+    try {
+        runSetupCommand('git', [
+            'init',
+            '-b',
+            'main'
+        ], {
+            cwd: targetDir,
+            stdio: 'inherit'
+        });
+    } catch  {
+        runSetupCommand('git', [
+            'init'
+        ], {
+            cwd: targetDir,
+            stdio: 'inherit'
+        });
+        runSetupCommand('git', [
+            'branch',
+            '-M',
+            'main'
+        ], {
+            cwd: targetDir,
+            stdio: 'inherit'
+        });
+    }
+}
+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',
+        '--no-tailwind',
+        '--workspace',
+        '--vertical',
+        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);
+        }
+    }
+    if (positionalArgs.length > 1) {
+        console.error(`Unexpected positional argument: ${positionalArgs[1]}`);
+        process.exit(1);
+    }
+    const projectNameArg = positionalArgs[0];
+    if (projectNameArg) {
+        if ('.' === projectNameArg) return {
+            name: node_path.basename(process.cwd()),
+            useCurrentDir: true
+        };
+        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;
+    const createPackage = readCreatePackageJson();
+    const version = createPackage.version || 'latest';
+    const ultramodernPackageVersion = isBleedingDevCreatePackage(createPackage) ? getBleedingDevFrameworkVersion(createPackage, version) : version;
+    const addVertical = detectVerticalFlag();
+    if (addVertical) {
+        const overridePackageSource = args.some((arg)=>arg.startsWith('--ultramodern-package-')) ? detectUltramodernPackageSource(args, ultramodernPackageVersion, createPackage) : void 0;
+        addUltramodernVertical({
+            workspaceRoot: process.cwd(),
+            name: generatedPackageName,
+            modernVersion: version,
+            enableTailwind: detectExplicitTailwindFlag(),
+            packageSource: overridePackageSource
+        });
+        const dim = '\x1b[2m\x1b[3m';
+        const reset = '\x1b[0m';
+        console.log(`${i18n.t(localeKeys.message.success)}\n`);
+        console.log(`${dim}   pnpm ultramodern:check${reset}\n`);
+        return;
+    }
+    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 generateWorkspace = detectUltramodernWorkspaceFlag();
+    if (generateWorkspace) {
+        const packageSource = resolveWorkspacePackageSource(args, createPackage, detectUltramodernPackageSource(args, ultramodernPackageVersion, createPackage));
+        generateUltramodernWorkspace({
+            targetDir,
+            packageName: generatedPackageName,
+            modernVersion: version,
+            enableTailwind: detectTailwindFlag(),
+            packageSource
+        });
+        initializeGeneratedGitRepository(targetDir);
+        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 packageSource = resolveSingleAppPackageSource(args, createPackage, detectUltramodernPackageSource(args, ultramodernPackageVersion, createPackage), useWorkspaceProtocol);
+    const templateManifest = createBuiltinTemplateManifest('install' === packageSource.strategy ? packageSource.modernPackageVersion : version);
+    validateTemplateManifest(templateManifest);
+    copyTemplate(templateDir, targetDir, {
+        packageName: generatedPackageName,
+        version: 'workspace' === packageSource.strategy ? WORKSPACE_PACKAGE_VERSION : packageSource.modernPackageVersion,
+        runtimeVersion: modernPackageSpecifier('@modern-js/runtime', packageSource),
+        appToolsVersion: modernPackageSpecifier('@modern-js/app-tools', packageSource),
+        adapterRstestVersion: modernPackageSpecifier('@modern-js/adapter-rstest', packageSource),
+        codeToolsVersion: modernPackageSpecifier('@modern-js/code-tools', packageSource),
+        createVersion: modernPackageSpecifier('@modern-js/create', packageSource),
+        tsconfigVersion: modernPackageSpecifier('@modern-js/tsconfig', packageSource),
+        pluginTanstackVersion: modernPackageSpecifier('@modern-js/plugin-tanstack', packageSource),
+        pluginBffVersion: modernPackageSpecifier('@modern-js/plugin-bff', packageSource),
+        pluginI18nVersion: modernPackageSpecifier('@modern-js/plugin-i18n', packageSource),
+        tanstackRouterVersion: TANSTACK_ROUTER_VERSION,
+        i18nextVersion: I18NEXT_VERSION,
+        reactVersion: REACT_VERSION,
+        reactDomVersion: REACT_DOM_VERSION,
+        reactI18nextVersion: REACT_I18NEXT_VERSION,
+        effectTsgoVersion: EFFECT_TSGO_VERSION,
+        typescriptNativePreviewVersion: TYPESCRIPT_NATIVE_PREVIEW_VERSION,
+        rstestCoreVersion: RSTEST_CORE_VERSION,
+        happyDomVersion: HAPPY_DOM_VERSION,
+        oxfmtVersion: OXFMT_VERSION,
+        oxlintVersion: OXLINT_VERSION,
+        postcssVersion: POSTCSS_VERSION,
+        ultraciteVersion: ULTRACITE_VERSION,
+        typesReactVersion: TYPES_REACT_VERSION,
+        typesReactDomVersion: TYPES_REACT_DOM_VERSION,
+        tailwindVersion: TAILWIND_VERSION,
+        tailwindPostcssVersion: TAILWIND_POSTCSS_VERSION,
+        pnpmVersion: PNPM_VERSION,
+        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;
+    packageJson.modernjs = {
+        ...packageJson.modernjs ?? {},
+        preset: 'presetUltramodern',
+        packageSource: {
+            strategy: packageSource.strategy,
+            config: './.modernjs/ultramodern-package-source.json'
+        }
+    };
+    if (isSubproject) {
+        delete packageJson['lint-staged'];
+        delete packageJson['simple-git-hooks'];
+        if (packageJson.scripts) {
+            delete packageJson.scripts.prepare;
+            delete packageJson.scripts['skills:install'];
+            delete packageJson.scripts['skills:check'];
+            delete packageJson.scripts.postinstall;
+        }
+        if (packageJson.devDependencies) {
+            delete packageJson.devDependencies['lint-staged'];
+            delete packageJson.devDependencies.lefthook;
+            delete packageJson.devDependencies['simple-git-hooks'];
+        }
+        node_fs.rmSync(node_path.join(targetDir, '.codex'), {
+            recursive: true,
+            force: true
+        });
+        node_fs.rmSync(node_path.join(targetDir, 'lefthook.yml'), {
+            force: true
+        });
+    }
+    node_fs.writeFileSync(targetPackageJson, `${JSON.stringify(packageJson, null, 2)}\n`);
+    writeTemplateManifestEvidence(targetDir, templateManifest);
+    writeSingleAppPackageSourceEvidence(targetDir, packageSource);
+    if (!isSubproject) initializeGeneratedGitRepository(targetDir);
+    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 = [
+        '.agents',
+        '.github',
+        '.gitignore.handlebars',
+        'AGENTS.md',
+        '.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 = renderTemplate(templateContent, {
+                    packageName: options.packageName,
+                    version: options.version,
+                    runtimeVersion: options.runtimeVersion,
+                    appToolsVersion: options.appToolsVersion,
+                    adapterRstestVersion: options.adapterRstestVersion,
+                    codeToolsVersion: options.codeToolsVersion,
+                    createVersion: options.createVersion,
+                    tsconfigVersion: options.tsconfigVersion,
+                    pluginTanstackVersion: options.pluginTanstackVersion,
+                    pluginBffVersion: options.pluginBffVersion,
+                    pluginI18nVersion: options.pluginI18nVersion,
+                    tanstackRouterVersion: options.tanstackRouterVersion,
+                    i18nextVersion: options.i18nextVersion,
+                    reactVersion: options.reactVersion,
+                    reactDomVersion: options.reactDomVersion,
+                    reactI18nextVersion: options.reactI18nextVersion,
+                    effectTsgoVersion: options.effectTsgoVersion,
+                    typescriptNativePreviewVersion: options.typescriptNativePreviewVersion,
+                    rstestCoreVersion: options.rstestCoreVersion,
+                    happyDomVersion: options.happyDomVersion,
+                    oxfmtVersion: options.oxfmtVersion,
+                    oxlintVersion: options.oxlintVersion,
+                    postcssVersion: options.postcssVersion,
+                    ultraciteVersion: options.ultraciteVersion,
+                    typesReactVersion: options.typesReactVersion,
+                    typesReactDomVersion: options.typesReactDomVersion,
+                    tailwindVersion: options.tailwindVersion,
+                    tailwindPostcssVersion: options.tailwindPostcssVersion,
+                    pnpmVersion: options.pnpmVersion,
+                    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,
+                    routerRuntimeImport: 'tanstack' === options.routerFramework ? '@modern-js/plugin-tanstack/runtime' : '@modern-js/runtime/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);
+});