@bleedingdev/modern-js-ultramodern-create 3.9.0-ultramodern.2 → 3.9.0-ultramodern.21

package/dist/esm/ultramodern-workspace/write-workspace.js

@@ -1,27 +1,27 @@
 import node_fs from "node:fs";
-import { RELEASE_COHORT_PROJECTION_PATH, copyCreateReleaseCohort, isCreatePackageSourceCheckout, readCreateReleaseCohort } from "../ultramodern-release-cohort.js";
+import { ULTRAMODERN_WORKSPACE_MODERN_PACKAGES, modernPackageSpecifier } from "../ultramodern-package-source.js";
+import { hasCreateReleaseCohort, isCreatePackageSourceCheckout, readCreateReleaseCohort, releaseCohortSelectors } from "../ultramodern-release-cohort.js";
 import { runFreshWorkspaceTransaction } from "./add-vertical/transaction.js";
 import { createSharedDesignTokensCss } from "./app-files.js";
 import { normalizeUltramodernBridgeConfig } from "./bridge-config.js";
-import { createDevelopmentOverlay, createOwnership, createTopology, createUltramodernConfig } from "./contracts.js";
-import { ULTRAMODERN_CONFIG_PATH, createShellHost, sharedPackages, shellApp } from "./descriptors.js";
+import { createDevelopmentOverlay, createOwnership, createTopology } from "./contracts.js";
+import { createShellHost, sharedPackages, shellApp } from "./descriptors.js";
 import { copyRootTemplate, formatGeneratedWorkspaceFiles, writeFile, writeFileReplacing, writeJson } from "./fs-io.js";
 import { createFileSnapshot, createGenerationResult, diffFileSnapshots } from "./generation-result.js";
 import { assertUniqueTailwindPrefixes, toPackageScope } from "./naming.js";
 import { runCodeSmithOverlays } from "./overlays.js";
 import { createRootPackageJson, createRootTsConfig, createSharedContractsIndex, createSharedPackage, createSharedPackageTsConfig, createTsConfigBase } from "./package-json.js";
 import { resolvePackageSource, resolveWorkspacePackageLinkingPolicy } from "./package-source.js";
-import { renderMinimumReleaseAgeExclude } from "./policy.js";
-import { DRIZZLE_ORM_VERSION, EFFECT_VERSION, EFFECT_VITEST_VERSION, I18NEXT_VERSION, MODULE_FEDERATION_VERSION, MSGPACKR_VERSION, NODE_FETCH_VERSION, NODE_VERSION, PNPM_VERSION, TANSTACK_HISTORY_VERSION, TANSTACK_ROUTER_CORE_VERSION, TANSTACK_ROUTER_VERSION, TYPESCRIPT_VERSION, WRANGLER_VERSION, ZOD_VERSION } from "./versions.js";
+import { EFFECT_VERSION, I18NEXT_VERSION, NODE_VERSION, PNPM_VERSION } from "./versions.js";
 import { writeGeneratedWorkspaceScripts } from "./workspace-scripts.js";
 import { writeApp } from "./write-app.js";
 import { createZeropsYaml } from "./zerops.js";
 function hasExplicitInstallRequest(options) {
     return void 0 !== options.packageSource && 'workspace' !== options.packageSource.strategy;
 }
-function writeSharedPackages(targetDir, scope) {
+function writeSharedPackages(targetDir, scope, packageSource) {
     for (const sharedPackage of sharedPackages){
-        writeJson(targetDir, `${sharedPackage.directory}/package.json`, createSharedPackage(scope, sharedPackage.id, sharedPackage.description));
+        writeJson(targetDir, `${sharedPackage.directory}/package.json`, createSharedPackage(scope, sharedPackage.id, sharedPackage.description, packageSource));
         writeJson(targetDir, `${sharedPackage.directory}/tsconfig.json`, createSharedPackageTsConfig(sharedPackage.directory));
     }
     writeFile(targetDir, 'packages/shared-contracts/src/index.ts', createSharedContractsIndex());
@@ -35,30 +35,25 @@ function writeSharedPackages(targetDir, scope) {
 `);
     writeFile(targetDir, 'packages/shared-design-tokens/src/tokens.css', createSharedDesignTokensCss());
 }
-function createCompactRootPackageJson(scope, packageSource, remotes, bridge) {
-    const rootPackage = createRootPackageJson(scope, packageSource, remotes, bridge);
-    if (rootPackage.modernjs?.packageSource && 'object' == typeof rootPackage.modernjs.packageSource) rootPackage.modernjs.packageSource.config = `./${ULTRAMODERN_CONFIG_PATH}`;
-    return rootPackage;
+function renderCatalogPolicy(packageSource) {
+    if ('install' !== packageSource.strategy) return '';
+    const catalog = ULTRAMODERN_WORKSPACE_MODERN_PACKAGES.map((name)=>`    ${JSON.stringify(name)}: ${JSON.stringify(modernPackageSpecifier(name, packageSource))}`).join('\n');
+    const cohort = hasCreateReleaseCohort() ? readCreateReleaseCohort() : void 0;
+    const pinsShippedCohort = cohort?.packages.every((item)=>modernPackageSpecifier(item.sourceName, packageSource) === `npm:${item.targetName}@${item.version}`);
+    const exclude = cohort && pinsShippedCohort ? `minimumReleaseAgeExclude:\n${releaseCohortSelectors(cohort).map((selector)=>`  - ${JSON.stringify(selector)}`).join('\n')}\n\n` : '';
+    return `catalogs:\n  ultramodern:\n${catalog}\n\n${exclude}`;
 }
-function createCompactUltramodernConfig(scope, modernVersion, packageSource, apps = [
-    createShellHost()
-], enableTailwind = true, bridge, additionalShells = [], primaryShell) {
-    const config = createUltramodernConfig(scope, modernVersion, packageSource, apps, enableTailwind, bridge, additionalShells, primaryShell);
-    if (config.packageSource && 'object' == typeof config.packageSource && !Array.isArray(config.packageSource)) delete config.packageSource.metadata;
-    return config;
-}
-function writePnpmWorkspacePackages(targetDir, bridge) {
-    if (!bridge) return;
+function writePnpmWorkspacePackages(targetDir, bridge, packageSource) {
     const pnpmWorkspacePath = `${targetDir}/pnpm-workspace.yaml`;
     const pnpmWorkspace = node_fs.readFileSync(pnpmWorkspacePath, 'utf-8');
     const packages = [
         'apps/*',
         'verticals/*',
         'packages/*',
-        ...bridge.workspacePackages.map((entry)=>entry.pattern)
+        ...bridge?.workspacePackages.map((entry)=>entry.pattern) ?? []
     ];
     const renderedPackages = packages.map((pattern)=>`  - ${pattern}`).join('\n');
-    writeFileReplacing(targetDir, 'pnpm-workspace.yaml', pnpmWorkspace.replace(/^packages:\r?\n(?: {2}- .+\r?\n)+/u, `packages:\n${renderedPackages}\n`));
+    writeFileReplacing(targetDir, 'pnpm-workspace.yaml', `${renderCatalogPolicy(packageSource)}${pnpmWorkspace.replace(/^packages:\r?\n(?: {2}- .+\r?\n)+/u, `packages:\n${renderedPackages}\n`)}`);
 }
 function generateUltramodernWorkspace(options) {
     const result = runFreshWorkspaceTransaction(options.targetDir, (stagingRoot)=>generateUltramodernWorkspaceInPlace({
@@ -71,19 +66,15 @@ function generateUltramodernWorkspaceInPlace(options, logicalWorkspaceRoot = opt
     const beforeFiles = createFileSnapshot(options.targetDir);
     const scope = toPackageScope(options.packageName);
     let packageSource;
-    let releaseCohort;
     if (isCreatePackageSourceCheckout()) {
-        if (hasExplicitInstallRequest(options)) throw new Error('A local @modern-js/ultramodern-create source checkout cannot satisfy an explicit install package source. Use workspace mode locally or run the packed published package with its authenticated release cohort projection.');
+        if (hasExplicitInstallRequest(options)) throw new Error('A local @modern-js/ultramodern-create source checkout cannot satisfy an explicit install package source. Use workspace mode locally or run the packed published package.');
         packageSource = resolvePackageSource({
             ...options,
             packageSource: {
                 strategy: 'workspace'
             }
         });
-    } else {
-        packageSource = resolvePackageSource(options);
-        if ('install' === packageSource.strategy) releaseCohort = readCreateReleaseCohort();
-    }
+    } else packageSource = resolvePackageSource(options);
     const bridge = normalizeUltramodernBridgeConfig(options.bridge);
     const enableTailwind = false !== options.enableTailwind;
     const initialVerticals = [];
@@ -98,13 +89,9 @@ function generateUltramodernWorkspaceInPlace(options, logicalWorkspaceRoot = opt
     node_fs.mkdirSync(options.targetDir, {
         recursive: true
     });
-    const minimumReleaseAgeExclude = renderMinimumReleaseAgeExclude({
-        packageSource,
-        releaseCohort
-    });
     const workspacePackageLinkingPolicy = resolveWorkspacePackageLinkingPolicy(packageSource);
     const excludedRootTemplates = new Set([
-        RELEASE_COHORT_PROJECTION_PATH
+        "scripts/setup-agent-reference-repos.mjs"
     ]);
     if (false === options.generateAgentFiles) {
         excludedRootTemplates.add('AGENTS.md.handlebars');
@@ -115,37 +102,23 @@ function generateUltramodernWorkspaceInPlace(options, logicalWorkspaceRoot = opt
         packageScope: scope,
         nodeVersion: NODE_VERSION,
         pnpmVersion: PNPM_VERSION,
-        nodeFetchVersion: NODE_FETCH_VERSION,
-        drizzleOrmVersion: DRIZZLE_ORM_VERSION,
         effectVersion: EFFECT_VERSION,
-        effectVitestVersion: EFFECT_VITEST_VERSION,
         i18nextVersion: I18NEXT_VERSION,
-        moduleFederationVersion: MODULE_FEDERATION_VERSION,
-        msgpackrVersion: MSGPACKR_VERSION,
-        zodVersion: ZOD_VERSION,
-        tanstackHistoryVersion: TANSTACK_HISTORY_VERSION,
-        tanstackRouterCoreVersion: TANSTACK_ROUTER_CORE_VERSION,
-        tanstackRouterVersion: TANSTACK_ROUTER_VERSION,
-        typescriptVersion: TYPESCRIPT_VERSION,
-        wranglerVersion: WRANGLER_VERSION,
-        minimumReleaseAgeExcludeYaml: 0 === minimumReleaseAgeExclude.length ? ' []' : `\n${minimumReleaseAgeExclude.map((selector)=>`  - '${selector}'`).join('\n')}`,
         workspacePackageLinkingYaml: Object.entries(workspacePackageLinkingPolicy).map(([key, value])=>`${key}: ${String(value)}\n`).join(''),
         tailwindEnabled: String(enableTailwind)
     }, excludedRootTemplates);
-    if (releaseCohort) copyCreateReleaseCohort(options.targetDir);
-    writePnpmWorkspacePackages(options.targetDir, bridge);
-    writeJson(options.targetDir, 'package.json', createCompactRootPackageJson(scope, packageSource, initialVerticals, bridge));
+    writePnpmWorkspacePackages(options.targetDir, bridge, packageSource);
+    writeJson(options.targetDir, 'package.json', createRootPackageJson(scope, packageSource, initialVerticals, bridge));
     if (initialVerticals.length > 0) writeFile(options.targetDir, 'zerops.yaml', `${createZeropsYaml(scope, createdApps)}\n`);
     writeJson(options.targetDir, 'tsconfig.base.json', createTsConfigBase());
     writeJson(options.targetDir, 'tsconfig.json', createRootTsConfig(createdApps));
     writeJson(options.targetDir, 'topology/reference-topology.json', createTopology(scope, initialVerticals));
     writeJson(options.targetDir, 'topology/ownership.json', createOwnership(scope, initialVerticals));
     writeJson(options.targetDir, 'topology/local-overlays/development.json', createDevelopmentOverlay(scope, initialVerticals));
-    writeJson(options.targetDir, ULTRAMODERN_CONFIG_PATH, createCompactUltramodernConfig(scope, options.modernVersion, packageSource, createdApps, enableTailwind, bridge));
     writeApp(options.targetDir, scope, shellApp, packageSource, enableTailwind, initialVerticals, bridge);
     for (const remote of initialVerticals)writeApp(options.targetDir, scope, remote, packageSource, enableTailwind, initialVerticals, bridge);
-    writeSharedPackages(options.targetDir, scope);
-    writeGeneratedWorkspaceScripts(options.targetDir, scope, enableTailwind, initialVerticals, releaseCohort);
+    writeSharedPackages(options.targetDir, scope, packageSource);
+    writeGeneratedWorkspaceScripts(options.targetDir);
     const preliminaryAfterFiles = createFileSnapshot(options.targetDir);
     const preliminaryDiff = diffFileSnapshots(beforeFiles, preliminaryAfterFiles);
     const preliminaryResult = createGenerationResult({
@@ -175,4 +148,4 @@ function generateUltramodernWorkspaceInPlace(options, logicalWorkspaceRoot = opt
         rewrittenPaths
     });
 }
-export { createCompactUltramodernConfig, generateUltramodernWorkspace, writeApp };
+export { generateUltramodernWorkspace, writeApp };

package/dist/esm/ultramodern-workspace/zerops.js

@@ -31,6 +31,8 @@ function createZeropsService(scope, app) {
         `  - setup: ${quoteYamlString(app.id)}`,
         '    build:',
         `      base: ${quoteYamlString(zeropsNodeRuntime)}`,
+        '      envVariables:',
+        `        ZE_FAIL_BUILD: ${quoteYamlString('true')}`,
         '      buildCommands:',
         '        - |',
         ...commands.map((command)=>`          ${command}`),

package/dist/esm-node/cli/package-source.js

@@ -3,7 +3,7 @@ import node_fs from "node:fs";
 import node_path from "node:path";
 import { fileURLToPath } from "node:url";
 import { resolveCreatePackageRoot } from "../create-package-root.js";
-import { BLEEDINGDEV_CREATE_PACKAGE, BLEEDINGDEV_FRAMEWORK_VERSION_ENV, BLEEDINGDEV_PACKAGE_NAME_PREFIX, BLEEDINGDEV_PACKAGE_SCOPE, LEGACY_BLEEDINGDEV_CREATE_PACKAGE, ULTRAMODERN_FRAMEWORK_VERSION_ENV, WORKSPACE_PACKAGE_VERSION } from "../ultramodern-package-source.js";
+import { BLEEDINGDEV_CREATE_PACKAGE, BLEEDINGDEV_PACKAGE_NAME_PREFIX, BLEEDINGDEV_PACKAGE_SCOPE, ULTRAMODERN_FRAMEWORK_VERSION_ENV, WORKSPACE_PACKAGE_VERSION } from "../ultramodern-package-source.js";
 import { isCreatePackageSourceCheckout } from "../ultramodern-release-cohort.js";
 import { WORKSPACE_PROTOCOL_FLAG, getOptionValue } from "./flags.js";
 import { runSetupCommand } from "./project-setup.js";
@@ -16,7 +16,7 @@ function readCreatePackageJson() {
     return JSON.parse(node_fs.readFileSync(createPackageJson, 'utf-8'));
 }
 function isBleedingDevCreatePackage(createPackage) {
-    return createPackage.name === BLEEDINGDEV_CREATE_PACKAGE || createPackage.name === LEGACY_BLEEDINGDEV_CREATE_PACKAGE;
+    return createPackage.name === BLEEDINGDEV_CREATE_PACKAGE;
 }
 function getBleedingDevFrameworkVersion(createPackage, fallbackVersion) {
     const frameworkVersion = createPackage.ultramodern?.frameworkVersion;
@@ -57,7 +57,7 @@ function hasExplicitUltramodernPackageSource(args, value) {
     return value ? configuredValue === value : void 0 !== configuredValue;
 }
 function readBleedingDevFrameworkVersionFromRegistry(fallbackVersion) {
-    const envVersion = (process.env[ULTRAMODERN_FRAMEWORK_VERSION_ENV] ?? process.env[BLEEDINGDEV_FRAMEWORK_VERSION_ENV])?.trim();
+    const envVersion = process.env[ULTRAMODERN_FRAMEWORK_VERSION_ENV]?.trim();
     if (envVersion) {
         if (!semverPattern.test(envVersion)) {
             console.error(`${ULTRAMODERN_FRAMEWORK_VERSION_ENV} must be a valid semver version`);

package/dist/esm-node/cli/project-setup.js

@@ -43,7 +43,7 @@ function isInsideGitWorkTree(targetDir) {
 }
 function initializeGeneratedGitRepository(targetDir) {
     assertGitAvailableForGeneratedProject();
-    if (isInsideGitWorkTree(targetDir)) return;
+    if (isInsideGitWorkTree(targetDir)) return false;
     try {
         runSetupCommand('git', [
             'init',
@@ -69,27 +69,7 @@ function initializeGeneratedGitRepository(targetDir) {
             stdio: 'inherit'
         });
     }
-    runSetupCommand('git', [
-        'add',
-        '-A'
-    ], {
-        cwd: targetDir,
-        stdio: 'inherit'
-    });
-    runSetupCommand('git', [
-        '-c',
-        'user.name=UltraModern',
-        '-c',
-        'user.email=ultramodern@bleedingdev.dev',
-        '-c',
-        'commit.gpgsign=false',
-        'commit',
-        '-m',
-        'chore: initial UltraModern scaffold'
-    ], {
-        cwd: targetDir,
-        stdio: 'inherit'
-    });
+    return true;
 }
 function isDirectoryEmpty(dirPath) {
     if (!node_fs.existsSync(dirPath)) return false;

package/dist/esm-node/index.js

@@ -3,7 +3,7 @@ import node_fs from "node:fs";
 import node_path from "node:path";
 import { fileURLToPath } from "node:url";
 import { runAgentsMd } from "./agents-md.js";
-import { DRY_RUN_FLAG, VERTICAL_FLAG, detectApiProtocolFlag, detectBffRuntime, detectCodeSmithOverlays, detectDryRunFlag, detectExplicitTailwindFlag, detectHorizontalRemoteFlag, detectLanguage, detectPresetFlag, detectTailwindFlag, readBridgeCliOptions, resolveVerticalCliInput } from "./cli/flags.js";
+import { DRY_RUN_FLAG, VERTICAL_FLAG, collectPositionalArgs, detectApiProtocolFlag, detectBffRuntime, detectCodeSmithOverlays, detectDryRunFlag, detectExplicitTailwindFlag, detectHorizontalRemoteFlag, detectLanguage, detectPresetFlag, detectTailwindFlag, readBridgeCliOptions, resolveVerticalCliInput } from "./cli/flags.js";
 import { showHelp, showVersion } from "./cli/help.js";
 import { detectUltramodernPackageSource, getBleedingDevFrameworkVersion, isBleedingDevCreatePackage, readCreatePackageJson, resolveWorkspacePackageSource } from "./cli/package-source.js";
 import { initializeGeneratedGitRepository } from "./cli/project-setup.js";
@@ -11,6 +11,7 @@ import { getProjectName } from "./cli/prompts.js";
 import { i18n, localeKeys } from "./locale/index.js";
 import { runUltramodernToolingCli } from "./ultramodern-tooling/commands.js";
 import { addUltramodernVertical, generateUltramodernWorkspace, planUltramodernVertical } from "./ultramodern-workspace/index.js";
+import { recoverFreshWorkspaceTransactions } from "./ultramodern-workspace/add-vertical/transaction.js";
 import { hasUltramodernBridgeCliOptions } from "./ultramodern-workspace/bridge-config.js";
 const src_dirname = node_path.dirname(fileURLToPath(import.meta.url));
 const templateDir = [
@@ -91,9 +92,11 @@ async function main() {
         console.log(`${dim}   pnpm check${reset}\n`);
         return;
     }
+    if (0 === collectPositionalArgs(args).length) recoverFreshWorkspaceTransactions(process.cwd());
     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;
+    recoverFreshWorkspaceTransactions(targetDir);
     if (node_fs.existsSync(targetDir)) {
         const files = node_fs.readdirSync(targetDir);
         if (files.length > 0) {
@@ -115,7 +118,7 @@ async function main() {
         packageSource,
         generateAgentFiles
     });
-    initializeGeneratedGitRepository(targetDir);
+    const initializedGitRepository = initializeGeneratedGitRepository(targetDir);
     const dim = '\x1b[2m\x1b[3m';
     const reset = '\x1b[0m';
     console.log(`${i18n.t(localeKeys.message.success)}\n`);
@@ -126,6 +129,11 @@ async function main() {
     })}${reset}`);
     console.log(`${dim}   ${i18n.t(localeKeys.message.step2)}${reset}`);
     console.log(`${dim}   pnpm check${reset}`);
+    if (initializedGitRepository) {
+        console.log(i18n.t(localeKeys.message.initialCommit));
+        console.log(`${dim}   git add .${reset}`);
+        console.log(`${dim}   git commit -m "chore: initial UltraModern scaffold"${reset}`);
+    }
     console.log(`${dim}   ${i18n.t(localeKeys.message.step3)}${reset}\n`);
 }
 main().catch((error)=>{

package/dist/esm-node/locale/en.js

@@ -18,7 +18,8 @@ const EN_LOCALE = {
         nextSteps: '📋 Next steps:',
         step1: 'cd {projectName}',
         step2: 'pnpm install',
-        step3: 'pnpm dev'
+        step3: 'pnpm dev',
+        initialCommit: 'Commit the checked scaffold before starting development or CI builds. Git uses your configured identity and hooks.'
     },
     agentsCmd: {
         created: '✔ Created {file}',

package/dist/esm-node/locale/zh.js

@@ -18,7 +18,8 @@ const ZH_LOCALE = {
         nextSteps: '📋 下一步：',
         step1: 'cd {projectName}',
         step2: 'pnpm install',
-        step3: 'pnpm dev'
+        step3: 'pnpm dev',
+        initialCommit: '启动开发或 CI 构建前，请提交已检查的项目。Git 将使用你配置的身份和钩子。'
     },
     agentsCmd: {
         created: '✔ 已创建 {file}',

package/dist/esm-node/ultramodern-package-source.js

@@ -2,11 +2,9 @@ import "node:module";
 const WORKSPACE_PACKAGE_VERSION = 'workspace:*';
 const ULTRAMODERN_CREATE_PACKAGE = '@modern-js/ultramodern-create';
 const BLEEDINGDEV_CREATE_PACKAGE = '@bleedingdev/modern-js-ultramodern-create';
-const LEGACY_BLEEDINGDEV_CREATE_PACKAGE = '@bleedingdev/modern-js-create';
 const BLEEDINGDEV_PACKAGE_SCOPE = 'bleedingdev';
 const BLEEDINGDEV_PACKAGE_NAME_PREFIX = 'modern-js-';
 const ULTRAMODERN_FRAMEWORK_VERSION_ENV = 'ULTRAMODERN_CREATE_FRAMEWORK_VERSION';
-const BLEEDINGDEV_FRAMEWORK_VERSION_ENV = 'MODERN_CREATE_ULTRAMODERN_FRAMEWORK_VERSION';
 const ULTRAMODERN_SINGLE_APP_MODERN_PACKAGES = [
     ULTRAMODERN_CREATE_PACKAGE,
     '@modern-js/code-tools',
@@ -16,16 +14,28 @@ const ULTRAMODERN_SINGLE_APP_MODERN_PACKAGES = [
     '@modern-js/plugin-i18n',
     '@modern-js/plugin-tanstack',
     '@modern-js/plugin-bff',
+    '@modern-js/plugin-bff-build-extensions',
+    '@modern-js/plugin-bff-extensions',
     '@modern-js/adapter-rstest'
 ];
 const ULTRAMODERN_WORKSPACE_MODERN_PACKAGES = [
+    '@modern-js/bff-effect',
+    '@modern-js/boundary-debugger',
     ULTRAMODERN_CREATE_PACKAGE,
     '@modern-js/code-tools',
     '@modern-js/app-tools',
     '@modern-js/plugin-bff',
+    '@modern-js/plugin-bff-build-extensions',
+    '@modern-js/plugin-bff-extensions',
     '@modern-js/plugin-i18n',
+    '@modern-js/i18n-integration',
     '@modern-js/plugin-tanstack',
-    '@modern-js/runtime'
+    '@modern-js/runtime',
+    '@modern-js/runtime-extensions',
+    '@modern-js/runtime-renderer-extensions',
+    '@modern-js/federation-runtime',
+    '@modern-js/app-tools-extensions',
+    '@modern-js/ultramodern-app-tools'
 ];
 function modernPackageVersion(packageSource) {
     return 'install' === packageSource.strategy ? packageSource.modernPackageVersion : WORKSPACE_PACKAGE_VERSION;
@@ -41,4 +51,4 @@ function modernPackageSpecifier(packageName, packageSource) {
     if (!packageSource.aliasScope) return packageSource.modernPackageVersion;
     return `npm:${modernAliasPackageName(packageName, packageSource)}@${packageSource.modernPackageVersion}`;
 }
-export { BLEEDINGDEV_CREATE_PACKAGE, BLEEDINGDEV_FRAMEWORK_VERSION_ENV, BLEEDINGDEV_PACKAGE_NAME_PREFIX, BLEEDINGDEV_PACKAGE_SCOPE, LEGACY_BLEEDINGDEV_CREATE_PACKAGE, ULTRAMODERN_CREATE_PACKAGE, ULTRAMODERN_FRAMEWORK_VERSION_ENV, ULTRAMODERN_SINGLE_APP_MODERN_PACKAGES, ULTRAMODERN_WORKSPACE_MODERN_PACKAGES, WORKSPACE_PACKAGE_VERSION, modernPackageSpecifier, modernPackageVersion };
+export { BLEEDINGDEV_CREATE_PACKAGE, BLEEDINGDEV_PACKAGE_NAME_PREFIX, BLEEDINGDEV_PACKAGE_SCOPE, ULTRAMODERN_CREATE_PACKAGE, ULTRAMODERN_FRAMEWORK_VERSION_ENV, ULTRAMODERN_SINGLE_APP_MODERN_PACKAGES, ULTRAMODERN_WORKSPACE_MODERN_PACKAGES, WORKSPACE_PACKAGE_VERSION, modernPackageSpecifier, modernPackageVersion };

package/dist/esm-node/ultramodern-release-cohort.js

@@ -1,8 +1,8 @@
 import "node:module";
 import node_fs from "node:fs";
 import node_path from "node:path";
-import { createPackageRoot, writeFile } from "./ultramodern-workspace/fs-io.js";
-const RELEASE_COHORT_PROJECTION_PATH = '.modernjs/release-cohort.json';
+import { createPackageRoot } from "./ultramodern-workspace/fs-io.js";
+const RELEASE_COHORT_PATH = 'release-cohort.json';
 const RELEASE_COHORT_PROJECTION_SCHEMA = 'bleedingdev.ultramodern.release-cohort';
 const RELEASE_COHORT_PROJECTION_SCHEMA_VERSION = 1;
 function assert(condition, message) {
@@ -99,23 +99,14 @@ function readCohortFile(filePath) {
     return parseUltramodernReleaseCohort(value);
 }
 function readCreateReleaseCohort() {
-    return readCohortFile(node_path.join(createPackageRoot, 'template-workspace', RELEASE_COHORT_PROJECTION_PATH));
+    return readCohortFile(node_path.join(createPackageRoot, RELEASE_COHORT_PATH));
 }
 function hasCreateReleaseCohort() {
-    return node_fs.existsSync(node_path.join(createPackageRoot, 'template-workspace', RELEASE_COHORT_PROJECTION_PATH));
+    return node_fs.existsSync(node_path.join(createPackageRoot, RELEASE_COHORT_PATH));
 }
 function isCreatePackageSourceCheckout() {
     return node_fs.existsSync(node_path.join(createPackageRoot, 'src'));
 }
-function readWorkspaceReleaseCohort(workspaceRoot) {
-    return readCohortFile(node_path.join(workspaceRoot, RELEASE_COHORT_PROJECTION_PATH));
-}
-function copyCreateReleaseCohort(workspaceRoot) {
-    const sourcePath = node_path.join(createPackageRoot, 'template-workspace', RELEASE_COHORT_PROJECTION_PATH);
-    const cohort = readCohortFile(sourcePath);
-    writeFile(workspaceRoot, RELEASE_COHORT_PROJECTION_PATH, node_fs.readFileSync(sourcePath, 'utf8'));
-    return cohort;
-}
 function assertReleaseCohortPackageSource(cohort, packageSource) {
     if ('install' !== packageSource.strategy) return;
     assert(packageSource.modernPackageVersion === cohort.release.version, `Package source release ${packageSource.modernPackageVersion} does not match authenticated release cohort ${cohort.release.version}.`);
@@ -131,4 +122,4 @@ function assertReleaseCohortPackageSource(cohort, packageSource) {
 function releaseCohortSelectors(cohort) {
     return cohort.packages.map((item)=>`${item.targetName}@${item.version}`).sort();
 }
-export { RELEASE_COHORT_PROJECTION_PATH, assertReleaseCohortPackageSource, copyCreateReleaseCohort, hasCreateReleaseCohort, isCreatePackageSourceCheckout, parseUltramodernReleaseCohort, readCreateReleaseCohort, readWorkspaceReleaseCohort, releaseCohortSelectors };
+export { RELEASE_COHORT_PATH, assertReleaseCohortPackageSource, hasCreateReleaseCohort, isCreatePackageSourceCheckout, parseUltramodernReleaseCohort, readCreateReleaseCohort, releaseCohortSelectors };

package/dist/esm-node/ultramodern-tooling/commands/cloudflare-output-verify.js

@@ -1,8 +1,19 @@
 import "node:module";
+import { createRequire } from "node:module";
 import node_path from "node:path";
+import { createCloudflarePublicUrlEnv } from "../../ultramodern-workspace/descriptors.js";
 import { readUltramodernConfig, workspaceAppsFromToolingConfig } from "../config.js";
-import { runRenderedModule } from "./context.js";
 import { readOption } from "./options.js";
+const REQUIRE_PUBLIC_URLS_FLAG = '--require-public-urls';
+const missingPublicUrl = ({ label, publicUrlEnv })=>{
+    if (!publicUrlEnv) return `${REQUIRE_PUBLIC_URLS_FLAG} needs --app, not --output (${label}).`;
+    const names = [
+        publicUrlEnv,
+        'MODERN_PUBLIC_SITE_URL',
+        'ULTRAMODERN_CLOUDFLARE_WORKERS_DEV_SUBDOMAIN'
+    ];
+    return names.some((name)=>process.env[name]?.trim()) ? void 0 : `Cloudflare deploy for ${label} needs ${names.join(', ')}.`;
+};
 const resolveCloudflareOutputVerifyTargets = (args, context)=>{
     const outputDirectory = readOption(args, '--output');
     const appId = readOption(args, '--app');
@@ -12,74 +23,56 @@ const resolveCloudflareOutputVerifyTargets = (args, context)=>{
             label: outputDirectory,
             outputDirectory: node_path.resolve(context.invocationCwd, outputDirectory)
         }
-    ] : workspaceAppsFromToolingConfig(readUltramodernConfig(context.workspaceRoot)).filter((app)=>!appId || app.id === appId).map((app)=>({
+    ] : workspaceAppsFromToolingConfig(readUltramodernConfig(context.workspaceRoot), context.workspaceRoot).filter((app)=>!appId || app.id === appId).map((app)=>({
             label: app.id,
-            outputDirectory: node_path.join(context.workspaceRoot, app.directory, '.output')
+            outputDirectory: node_path.join(context.workspaceRoot, app.directory, '.output'),
+            publicUrlEnv: createCloudflarePublicUrlEnv(app)
         }));
     if (0 === targets.length) throw new Error(`No generated UltraModern app matched ${appId}.`);
     return targets;
 };
-const renderCloudflareOutputVerifyModule = ({ workspaceRoot, targets, excludePaths })=>`
-import { createRequire } from 'node:module';
-import path from 'node:path';
-
-const workspaceRoot = ${JSON.stringify(workspaceRoot)};
-const targets = ${JSON.stringify(targets, null, 2)};
-const scanRoots = [workspaceRoot];
-const excludePaths = ${JSON.stringify(excludePaths)};
-const verifierRequire = createRequire(path.join(workspaceRoot, 'package.json'));
-const {
-  verifyCloudflareOutput,
-  verifyCloudflareOutputMutationPolicy,
-} = verifierRequire('@modern-js/app-tools/cloudflare-output-verifier');
-
-let failed = false;
-for (const target of targets) {
-  const result = await verifyCloudflareOutput({
-    outputDirectory: target.outputDirectory,
-    importWorker: true,
-  });
-  if (result.ok) {
-    console.log(\`[ultramodern] Cloudflare output verified: \${target.label}\`);
-  } else {
-    failed = true;
-    console.error(\`[ultramodern] Cloudflare output failed: \${target.label}\`);
-    for (const issue of result.issues) {
-      console.error(\`- \${issue.code}: \${issue.message}\${issue.path ? \` (\${issue.path})\` : ''}\`);
-    }
-  }
-}
-
-if (scanRoots.length > 0) {
-  const policyResult = await verifyCloudflareOutputMutationPolicy({ scanRoots, excludePaths });
-  if (!policyResult.ok) {
-    failed = true;
-    console.error('[ultramodern] generated-output mutation policy failed');
-    for (const issue of policyResult.issues) {
-      console.error(\`- \${issue.code}: \${issue.message}\${issue.path ? \` (\${issue.path})\` : ''}\`);
-    }
-  }
-}
-
-process.exit(failed ? 1 : 0);
-`;
-function runCloudflareOutputVerify(args, context) {
+async function runCloudflareOutputVerify(args, context) {
     if (args.includes('--help') || args.includes('-h')) {
         process.stdout.write(`Usage:
-  ultramodern-create ultramodern cloudflare-output-verify [--app <id> | --output <dir>]
+  ultramodern-create ultramodern cloudflare-output-verify [--app <id> | --output <dir>] [--require-public-urls]
 
 Verifies generated Cloudflare output against the UltraModern worker contract.
 Without --app or --output, every generated workspace app is verified.
+--require-public-urls also fails an app that has no public URL to deploy to.
 `);
         return 0;
     }
-    const source = renderCloudflareOutputVerifyModule({
-        workspaceRoot: context.workspaceRoot,
-        targets: resolveCloudflareOutputVerifyTargets(args, context),
-        excludePaths: [
-            node_path.join(context.workspaceRoot, "scripts", 'validate-ultramodern-workspace.mts')
-        ]
+    const targets = resolveCloudflareOutputVerifyTargets(args, context);
+    if (args.includes(REQUIRE_PUBLIC_URLS_FLAG)) {
+        const missing = targets.map(missingPublicUrl).filter((message)=>Boolean(message));
+        if (missing.length > 0) throw new Error(missing.join('\n'));
+    }
+    const verifierRequire = createRequire(node_path.join(context.workspaceRoot, 'package.json'));
+    const { verifyCloudflareOutput, verifyCloudflareOutputMutationPolicy } = verifierRequire('@modern-js/app-tools-extensions/cloudflare-output-verifier');
+    let failed = false;
+    for (const target of targets){
+        const result = await verifyCloudflareOutput({
+            outputDirectory: target.outputDirectory,
+            importWorker: true
+        });
+        if (result.ok) console.log(`[ultramodern] Cloudflare output verified: ${target.label}`);
+        else {
+            failed = true;
+            console.error(`[ultramodern] Cloudflare output failed: ${target.label}`);
+            for (const issue of result.issues)console.error(`- ${issue.code}: ${issue.message}${issue.path ? ` (${issue.path})` : ''}`);
+        }
+    }
+    const policyResult = await verifyCloudflareOutputMutationPolicy({
+        scanRoots: [
+            context.workspaceRoot
+        ],
+        excludePaths: []
     });
-    return runRenderedModule(source, context);
+    if (!policyResult.ok) {
+        failed = true;
+        console.error('[ultramodern] generated-output mutation policy failed');
+        for (const issue of policyResult.issues)console.error(`- ${issue.code}: ${issue.message}${issue.path ? ` (${issue.path})` : ''}`);
+    }
+    return failed ? 1 : 0;
 }
 export { runCloudflareOutputVerify };

package/dist/esm-node/ultramodern-tooling/commands/context.js

@@ -1,18 +1,22 @@
 import "node:module";
 import { spawnSync } from "node:child_process";
-import node_fs from "node:fs";
-import node_os from "node:os";
+import { constants } from "node:os";
 import node_path from "node:path";
 import { fileURLToPath } from "node:url";
 import { resolveCreatePackageRoot } from "../../create-package-root.js";
 import { generatedToolingCommandList, generatedToolingCommands } from "../../ultramodern-workspace/tooling-command-catalog.js";
 const context_dirname = node_path.dirname(fileURLToPath(import.meta.url));
 const createPackageRoot = resolveCreatePackageRoot(context_dirname);
+const AD_HOC_TOOLING_COMMANDS = {
+    syncDeliveryUnit: 'sync-delivery-unit',
+    skills: 'skills'
+};
 function printHelp() {
     const commands = [
         ...generatedToolingCommandList().map((command)=>`  ${command}`),
-        '  skills install',
-        '  skills check'
+        `  ${AD_HOC_TOOLING_COMMANDS.syncDeliveryUnit}`,
+        `  ${AD_HOC_TOOLING_COMMANDS.skills} install`,
+        `  ${AD_HOC_TOOLING_COMMANDS.skills} check`
     ].join('\n');
     process.stdout.write(`Usage:
   ultramodern-create ultramodern <command> [args]
@@ -35,7 +39,7 @@ function spawnNodeScript(relativeScriptPath, args, context, options = {}) {
         stdio: 'inherit'
     });
     if (result.error) throw result.error;
-    return result.status ?? 1;
+    return result.status ?? (result.signal ? 128 + constants.signals[result.signal] : 1);
 }
 function runTemplateBackedToolingCommand(command, args, context) {
     const toolingCommand = generatedToolingCommands.find((candidate)=>candidate.command === command);
@@ -44,24 +48,4 @@ function runTemplateBackedToolingCommand(command, args, context) {
         cwd: 'invocation' === toolingCommand.cwd ? context.invocationCwd : context.workspaceRoot
     });
 }
-function runRenderedModule(source, context) {
-    const tempDir = node_fs.mkdtempSync(node_path.join(node_os.tmpdir(), 'ultramodern-tool-'));
-    const tempFile = node_path.join(tempDir, 'command.mjs');
-    try {
-        node_fs.writeFileSync(tempFile, source, 'utf-8');
-        const result = spawnSync(process.execPath, [
-            tempFile
-        ], {
-            cwd: context.workspaceRoot,
-            stdio: 'inherit'
-        });
-        if (result.error) throw result.error;
-        return result.status ?? 1;
-    } finally{
-        node_fs.rmSync(tempDir, {
-            force: true,
-            recursive: true
-        });
-    }
-}
-export { createPackageRoot, printHelp, runRenderedModule, runTemplateBackedToolingCommand, spawnNodeScript };
+export { AD_HOC_TOOLING_COMMANDS, createPackageRoot, printHelp, runTemplateBackedToolingCommand, spawnNodeScript };

package/dist/esm-node/ultramodern-tooling/commands/routes-generate-app.js

@@ -0,0 +1,36 @@
+import "node:module";
+import { createRequire } from "node:module";
+import node_path from "node:path";
+import { pathToFileURL } from "node:url";
+async function main() {
+    const [appDirectory, label, mode] = process.argv.slice(2);
+    try {
+        if (!appDirectory || !label) throw new Error('Route generation requires an app directory and label.');
+        const appRequire = createRequire(node_path.join(appDirectory, 'package.json'));
+        const pluginUrl = pathToFileURL(appRequire.resolve('@modern-js/plugin-tanstack')).href;
+        const plugin = await import(pluginUrl);
+        if ('manifest' === mode) {
+            await plugin.writeRouteMetadataManifest({
+                appDirectory
+            });
+            console.log(`[ultramodern] Route metadata manifest generated: ${label}`);
+        } else {
+            await plugin.generateTanstackRouteArtifacts({
+                appDirectory
+            });
+            console.log(`[ultramodern] TanStack route artifacts generated: ${label}`);
+        }
+    } catch (error) {
+        process.exitCode = 1;
+        console.error(`[ultramodern] TanStack route generation failed: ${label}`);
+        let current = error;
+        let depth = 0;
+        while(current){
+            const detail = current instanceof Error ? current.stack ?? `${current.name}: ${current.message}` : String(current);
+            console.error(`${0 === depth ? '-' : '  caused by:'} ${detail}`);
+            current = current instanceof Error ? current.cause : void 0;
+            depth += 1;
+        }
+    }
+}
+main();