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

package/dist/cjs/ultramodern-release-cohort.cjs

@@ -37,14 +37,13 @@ var __webpack_require__ = {};
 var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
-    RELEASE_COHORT_PROJECTION_PATH: ()=>RELEASE_COHORT_PROJECTION_PATH,
+    RELEASE_COHORT_PATH: ()=>RELEASE_COHORT_PATH,
+    assertReleaseCohortAliasRequest: ()=>assertReleaseCohortAliasRequest,
     assertReleaseCohortPackageSource: ()=>assertReleaseCohortPackageSource,
-    copyCreateReleaseCohort: ()=>copyCreateReleaseCohort,
     hasCreateReleaseCohort: ()=>hasCreateReleaseCohort,
     isCreatePackageSourceCheckout: ()=>isCreatePackageSourceCheckout,
     parseUltramodernReleaseCohort: ()=>parseUltramodernReleaseCohort,
     readCreateReleaseCohort: ()=>readCreateReleaseCohort,
-    readWorkspaceReleaseCohort: ()=>readWorkspaceReleaseCohort,
     releaseCohortSelectors: ()=>releaseCohortSelectors
 });
 const external_node_fs_namespaceObject = require("node:fs");
@@ -52,9 +51,9 @@ var external_node_fs_default = /*#__PURE__*/ __webpack_require__.n(external_node
 const external_node_path_namespaceObject = require("node:path");
 var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
 const fs_io_cjs_namespaceObject = require("./ultramodern-workspace/fs-io.cjs");
-const RELEASE_COHORT_PROJECTION_PATH = '.modernjs/release-cohort.json';
+const RELEASE_COHORT_PATH = 'release-cohort.json';
 const RELEASE_COHORT_PROJECTION_SCHEMA = 'bleedingdev.ultramodern.release-cohort';
-const RELEASE_COHORT_PROJECTION_SCHEMA_VERSION = 1;
+const RELEASE_COHORT_PROJECTION_SCHEMA_VERSION = 2;
 function assert(condition, message) {
     if (!condition) throw new Error(message);
 }
@@ -94,6 +93,7 @@ function parseUltramodernReleaseCohort(value) {
         'release',
         'schema',
         'schemaVersion',
+        'sidecars',
         'source'
     ], 'Release cohort projection');
     const cohort = value;
@@ -133,6 +133,25 @@ function parseUltramodernReleaseCohort(value) {
         packageTargetNames.add(item.targetName);
     }
     assert(JSON.stringify(packageSourceNames) === JSON.stringify(aliasNames), 'Release cohort packages must exactly match aliases in source-name order.');
+    assert(Array.isArray(cohort.sidecars), 'Release cohort sidecars must be an array.');
+    const sidecarNames = [];
+    for (const [index, item] of cohort.sidecars.entries()){
+        const label = `Release cohort sidecars[${index}]`;
+        assertExactKeys(item, [
+            'name',
+            'version'
+        ], label);
+        assertNonEmptyString(item.name, `${label}.name`);
+        assertNonEmptyString(item.version, `${label}.version`);
+        assert(/^@bleedingdev\/[a-z0-9][a-z0-9.-]*$/u.test(item.name), `${label}.name must name an owned sidecar.`);
+        assert(/^\d+\.\d+\.\d+$/u.test(item.version), `${label}.version must be an exact stable version.`);
+        assert(!item.name.startsWith('@bleedingdev/modern-js-') && !packageTargetNames.has(item.name), `${label}.name uses a reserved cohort package identity.`);
+        assert(!sidecarNames.includes(item.name), `${label}.name duplicates a sidecar.`);
+        sidecarNames.push(item.name);
+    }
+    assert(JSON.stringify(sidecarNames) === JSON.stringify([
+        ...sidecarNames
+    ].sort()), 'Release cohort sidecars must be in name order.');
     return cohort;
 }
 function readCohortFile(filePath) {
@@ -149,23 +168,14 @@ function readCohortFile(filePath) {
     return parseUltramodernReleaseCohort(value);
 }
 function readCreateReleaseCohort() {
-    return readCohortFile(external_node_path_default().join(fs_io_cjs_namespaceObject.createPackageRoot, 'template-workspace', RELEASE_COHORT_PROJECTION_PATH));
+    return readCohortFile(external_node_path_default().join(fs_io_cjs_namespaceObject.createPackageRoot, RELEASE_COHORT_PATH));
 }
 function hasCreateReleaseCohort() {
-    return external_node_fs_default().existsSync(external_node_path_default().join(fs_io_cjs_namespaceObject.createPackageRoot, 'template-workspace', RELEASE_COHORT_PROJECTION_PATH));
+    return external_node_fs_default().existsSync(external_node_path_default().join(fs_io_cjs_namespaceObject.createPackageRoot, RELEASE_COHORT_PATH));
 }
 function isCreatePackageSourceCheckout() {
     return external_node_fs_default().existsSync(external_node_path_default().join(fs_io_cjs_namespaceObject.createPackageRoot, 'src'));
 }
-function readWorkspaceReleaseCohort(workspaceRoot) {
-    return readCohortFile(external_node_path_default().join(workspaceRoot, RELEASE_COHORT_PROJECTION_PATH));
-}
-function copyCreateReleaseCohort(workspaceRoot) {
-    const sourcePath = external_node_path_default().join(fs_io_cjs_namespaceObject.createPackageRoot, 'template-workspace', RELEASE_COHORT_PROJECTION_PATH);
-    const cohort = readCohortFile(sourcePath);
-    (0, fs_io_cjs_namespaceObject.writeFile)(workspaceRoot, RELEASE_COHORT_PROJECTION_PATH, external_node_fs_default().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}.`);
@@ -179,26 +189,34 @@ function assertReleaseCohortPackageSource(cohort, packageSource) {
     return cohort;
 }
 function releaseCohortSelectors(cohort) {
-    return cohort.packages.map((item)=>`${item.targetName}@${item.version}`).sort();
+    return [
+        ...cohort.packages.map((item)=>`${item.targetName}@${item.version}`),
+        ...cohort.sidecars.map((item)=>`${item.name}@${item.version}`)
+    ].sort();
+}
+function assertReleaseCohortAliasRequest(cohort, request, label) {
+    if ('string' != typeof request || !request.startsWith('npm:@bleedingdev/')) return;
+    const match = /^npm:(@bleedingdev\/[^@]+)@([^@]+)$/u.exec(request);
+    assert(match, `${label} must name an exact authenticated owned alias.`);
+    const entry = cohort.packages.find((item)=>item.targetName === match[1]) ?? cohort.sidecars.find((item)=>item.name === match[1]);
+    assert(entry && entry.version === match[2], `${label} owned alias disagrees with the installed release cohort: ${request}.`);
 }
-exports.RELEASE_COHORT_PROJECTION_PATH = __webpack_exports__.RELEASE_COHORT_PROJECTION_PATH;
+exports.RELEASE_COHORT_PATH = __webpack_exports__.RELEASE_COHORT_PATH;
+exports.assertReleaseCohortAliasRequest = __webpack_exports__.assertReleaseCohortAliasRequest;
 exports.assertReleaseCohortPackageSource = __webpack_exports__.assertReleaseCohortPackageSource;
-exports.copyCreateReleaseCohort = __webpack_exports__.copyCreateReleaseCohort;
 exports.hasCreateReleaseCohort = __webpack_exports__.hasCreateReleaseCohort;
 exports.isCreatePackageSourceCheckout = __webpack_exports__.isCreatePackageSourceCheckout;
 exports.parseUltramodernReleaseCohort = __webpack_exports__.parseUltramodernReleaseCohort;
 exports.readCreateReleaseCohort = __webpack_exports__.readCreateReleaseCohort;
-exports.readWorkspaceReleaseCohort = __webpack_exports__.readWorkspaceReleaseCohort;
 exports.releaseCohortSelectors = __webpack_exports__.releaseCohortSelectors;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
-    "RELEASE_COHORT_PROJECTION_PATH",
+    "RELEASE_COHORT_PATH",
+    "assertReleaseCohortAliasRequest",
     "assertReleaseCohortPackageSource",
-    "copyCreateReleaseCohort",
     "hasCreateReleaseCohort",
     "isCreatePackageSourceCheckout",
     "parseUltramodernReleaseCohort",
     "readCreateReleaseCohort",
-    "readWorkspaceReleaseCohort",
     "releaseCohortSelectors"
 ].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
 Object.defineProperty(exports, '__esModule', {

package/dist/cjs/ultramodern-tooling/commands/cloudflare-output-verify.cjs

@@ -39,11 +39,22 @@ __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
     runCloudflareOutputVerify: ()=>runCloudflareOutputVerify
 });
+const external_node_module_namespaceObject = require("node:module");
 const external_node_path_namespaceObject = require("node:path");
 var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
+const descriptors_cjs_namespaceObject = require("../../ultramodern-workspace/descriptors.cjs");
 const external_config_cjs_namespaceObject = require("../config.cjs");
-const external_context_cjs_namespaceObject = require("./context.cjs");
 const external_options_cjs_namespaceObject = require("./options.cjs");
+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 = (0, external_options_cjs_namespaceObject.readOption)(args, '--output');
     const appId = (0, external_options_cjs_namespaceObject.readOption)(args, '--app');
@@ -55,73 +66,55 @@ const resolveCloudflareOutputVerifyTargets = (args, context)=>{
         }
     ] : (0, external_config_cjs_namespaceObject.workspaceAppsFromToolingConfig)((0, external_config_cjs_namespaceObject.readUltramodernConfig)(context.workspaceRoot), context.workspaceRoot).filter((app)=>!appId || app.id === appId).map((app)=>({
             label: app.id,
-            outputDirectory: external_node_path_default().join(context.workspaceRoot, app.directory, '.output')
+            outputDirectory: external_node_path_default().join(context.workspaceRoot, app.directory, '.output'),
+            publicUrlEnv: (0, descriptors_cjs_namespaceObject.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-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})\` : ''}\`);
-    }
-  }
-}
-
-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: [
-            external_node_path_default().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 = (0, external_node_module_namespaceObject.createRequire)(external_node_path_default().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 (0, external_context_cjs_namespaceObject.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;
 }
 exports.runCloudflareOutputVerify = __webpack_exports__.runCloudflareOutputVerify;
 for(var __rspack_i in __webpack_exports__)if (-1 === [

package/dist/cjs/ultramodern-tooling/commands/context.cjs

@@ -43,15 +43,11 @@ __webpack_require__.d(__webpack_exports__, {
     AD_HOC_TOOLING_COMMANDS: ()=>AD_HOC_TOOLING_COMMANDS,
     createPackageRoot: ()=>createPackageRoot,
     printHelp: ()=>printHelp,
-    runRenderedModule: ()=>runRenderedModule,
     runTemplateBackedToolingCommand: ()=>runTemplateBackedToolingCommand,
     spawnNodeScript: ()=>spawnNodeScript
 });
 const external_node_child_process_namespaceObject = require("node:child_process");
-const external_node_fs_namespaceObject = require("node:fs");
-var external_node_fs_default = /*#__PURE__*/ __webpack_require__.n(external_node_fs_namespaceObject);
 const external_node_os_namespaceObject = require("node:os");
-var external_node_os_default = /*#__PURE__*/ __webpack_require__.n(external_node_os_namespaceObject);
 const external_node_path_namespaceObject = require("node:path");
 var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
 const external_node_url_namespaceObject = require("node:url");
@@ -91,7 +87,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 + external_node_os_namespaceObject.constants.signals[result.signal] : 1);
 }
 function runTemplateBackedToolingCommand(command, args, context) {
     const toolingCommand = tooling_command_catalog_cjs_namespaceObject.generatedToolingCommands.find((candidate)=>candidate.command === command);
@@ -100,37 +96,15 @@ function runTemplateBackedToolingCommand(command, args, context) {
         cwd: 'invocation' === toolingCommand.cwd ? context.invocationCwd : context.workspaceRoot
     });
 }
-function runRenderedModule(source, context) {
-    const tempDir = external_node_fs_default().mkdtempSync(external_node_path_default().join(external_node_os_default().tmpdir(), 'ultramodern-tool-'));
-    const tempFile = external_node_path_default().join(tempDir, 'command.mjs');
-    try {
-        external_node_fs_default().writeFileSync(tempFile, source, 'utf-8');
-        const result = (0, external_node_child_process_namespaceObject.spawnSync)(process.execPath, [
-            tempFile
-        ], {
-            cwd: context.workspaceRoot,
-            stdio: 'inherit'
-        });
-        if (result.error) throw result.error;
-        return result.status ?? 1;
-    } finally{
-        external_node_fs_default().rmSync(tempDir, {
-            force: true,
-            recursive: true
-        });
-    }
-}
 exports.AD_HOC_TOOLING_COMMANDS = __webpack_exports__.AD_HOC_TOOLING_COMMANDS;
 exports.createPackageRoot = __webpack_exports__.createPackageRoot;
 exports.printHelp = __webpack_exports__.printHelp;
-exports.runRenderedModule = __webpack_exports__.runRenderedModule;
 exports.runTemplateBackedToolingCommand = __webpack_exports__.runTemplateBackedToolingCommand;
 exports.spawnNodeScript = __webpack_exports__.spawnNodeScript;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
     "AD_HOC_TOOLING_COMMANDS",
     "createPackageRoot",
     "printHelp",
-    "runRenderedModule",
     "runTemplateBackedToolingCommand",
     "spawnNodeScript"
 ].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];

package/dist/cjs/ultramodern-tooling/commands/routes-generate-app.cjs

@@ -0,0 +1,69 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+var __webpack_exports__ = {};
+const external_node_module_namespaceObject = require("node:module");
+const external_node_path_namespaceObject = require("node:path");
+var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
+const external_node_url_namespaceObject = require("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 = (0, external_node_module_namespaceObject.createRequire)(external_node_path_default().join(appDirectory, 'package.json'));
+        if ('manifest' === mode) {
+            const pluginUrl = (0, external_node_url_namespaceObject.pathToFileURL)(appRequire.resolve('@modern-js/plugin-tanstack')).href;
+            const { writeRouteMetadataManifest } = await import(pluginUrl);
+            await writeRouteMetadataManifest({
+                appDirectory
+            });
+            console.log(`[ultramodern] Route metadata manifest generated: ${label}`);
+            return;
+        }
+        const cliUrl = (0, external_node_url_namespaceObject.pathToFileURL)(appRequire.resolve('@modern-js/ultramodern-app-tools/cli')).href;
+        const { generateRouteArtifacts } = await import(cliUrl);
+        await generateRouteArtifacts({
+            appDirectory
+        });
+        console.log(`[ultramodern] Route artifacts generated: ${label}`);
+    } catch (error) {
+        process.exitCode = 1;
+        console.error(`[ultramodern] 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();
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/ultramodern-tooling/commands/routes-generate.cjs

@@ -41,77 +41,50 @@ __webpack_require__.d(__webpack_exports__, {
 });
 const external_node_path_namespaceObject = require("node:path");
 var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
+const descriptors_cjs_namespaceObject = require("../../ultramodern-workspace/descriptors.cjs");
 const external_config_cjs_namespaceObject = require("../config.cjs");
 const external_context_cjs_namespaceObject = require("./context.cjs");
 const external_options_cjs_namespaceObject = require("./options.cjs");
 const resolveRoutesGenerateTargets = (args, context)=>{
     const appId = (0, external_options_cjs_namespaceObject.readOption)(args, '--app');
-    const targets = (0, external_config_cjs_namespaceObject.workspaceAppsFromToolingConfig)((0, external_config_cjs_namespaceObject.readUltramodernConfig)(context.workspaceRoot), context.workspaceRoot).filter((app)=>!appId || app.id === appId).map((app)=>({
+    const workspace = (0, external_config_cjs_namespaceObject.readUltramodernWorkspaceInputs)(context.workspaceRoot);
+    const targets = workspace.apps.filter((app)=>!appId || app.id === appId).filter(descriptors_cjs_namespaceObject.appEmitsBrowserUi).map((app)=>({
             label: app.id,
             appDirectory: external_node_path_default().join(context.workspaceRoot, app.directory)
         }));
     if (0 === targets.length) throw new Error(`No generated UltraModern app matched ${appId ?? '<any>'}.`);
     return targets;
 };
-const renderRoutesGenerateModule = ({ workspaceRoot, targets })=>`
-import { createRequire } from 'node:module';
-import path from 'node:path';
-import { pathToFileURL } from 'node:url';
-
-const workspaceRoot = ${JSON.stringify(workspaceRoot)};
-const targets = ${JSON.stringify(targets, null, 2)};
-const appRequire = createRequire(path.join(workspaceRoot, 'package.json'));
-const pluginUrl = pathToFileURL(
-  appRequire.resolve('@modern-js/plugin-tanstack'),
-).href;
-const { generateTanstackRouteArtifacts } = await import(pluginUrl);
-
-let failed = false;
-// Sequential — the app-tools cli singleton is not re-entrant.
-for (const target of targets) {
-  try {
-    await generateTanstackRouteArtifacts({ appDirectory: target.appDirectory });
-    console.log(\`[ultramodern] TanStack route artifacts generated: \${target.label}\`);
-  } catch (error) {
-    failed = true;
-    console.error(\`[ultramodern] TanStack route generation failed: \${target.label}\`);
-    // Print the full underlying failure, including the cause chain. The
-    // route-generate crash is often an opaque node error thrown deep inside
-    // app-tools/plugin (e.g. a path TypeError), so surfacing only
-    // \`error.message\` swallows the stack that points at the real culprit.
-    let current = error;
-    let depth = 0;
-    while (current) {
-      const label = depth === 0 ? '-' : '  caused by:';
-      const detail =
-        current instanceof Error
-          ? current.stack ?? \`\${current.name}: \${current.message}\`
-          : String(current);
-      console.error(\`\${label} \${detail}\`);
-      current = current instanceof Error ? current.cause : undefined;
-      depth += 1;
-    }
-  }
-}
-
-process.exit(failed ? 1 : 0);
-`;
-function runRoutesGenerate(args, context) {
+async function runRoutesGenerate(args, context) {
     if (args.includes('--help') || args.includes('-h')) {
         process.stdout.write(`Usage:
-  ultramodern-create ultramodern routes-generate [--app <id>]
+  ultramodern-create ultramodern routes-generate [--app <id>] [--manifest-only]
+
+Regenerates routes and entries through each application's configured renderer
+without running dev or build. React apps also regenerate
+src/routes/ultramodern-route-metadata.ts from their route.meta.ts files.
+Without --app, every generated workspace app with a UI is regenerated.
 
-Regenerates TanStack route artifacts (router.gen.ts, register.gen.d.ts) for
-generated UltraModern apps without running dev or build. Without --app, every
-generated workspace app is regenerated.
+--manifest-only writes only the route metadata manifest. It never loads the
+app config, so app dev and build scripts run it before \`ultramodern dev\` and
+\`ultramodern build\`, which regenerate the router artifacts themselves.
 `);
         return 0;
     }
-    const source = renderRoutesGenerateModule({
-        workspaceRoot: context.workspaceRoot,
-        targets: resolveRoutesGenerateTargets(args, context)
-    });
-    return (0, external_context_cjs_namespaceObject.runRenderedModule)(source, context);
+    const targets = resolveRoutesGenerateTargets(args, context);
+    const mode = args.includes('--manifest-only') ? 'manifest' : 'all';
+    let failed = false;
+    for (const target of targets){
+        const status = (0, external_context_cjs_namespaceObject.spawnNodeScript)('dist/esm-node/ultramodern-tooling/commands/routes-generate-app.js', [
+            target.appDirectory,
+            target.label,
+            mode
+        ], context, {
+            cwd: target.appDirectory
+        });
+        failed ||= 0 !== status;
+    }
+    return failed ? 1 : 0;
 }
 exports.runRoutesGenerate = __webpack_exports__.runRoutesGenerate;
 for(var __rspack_i in __webpack_exports__)if (-1 === [

package/dist/cjs/ultramodern-tooling/commands/validate.cjs

@@ -1,14 +1,5 @@
 "use strict";
 var __webpack_require__ = {};
-(()=>{
-    __webpack_require__.n = (module)=>{
-        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
-        __webpack_require__.d(getter, {
-            a: getter
-        });
-        return getter;
-    };
-})();
 (()=>{
     __webpack_require__.d = (exports1, getters, values)=>{
         var define = (defs, kind)=>{
@@ -39,47 +30,16 @@ __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
     runValidate: ()=>runValidate
 });
-const external_node_path_namespaceObject = require("node:path");
-var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
-const external_ultramodern_release_cohort_cjs_namespaceObject = require("../../ultramodern-release-cohort.cjs");
-const contracts_cjs_namespaceObject = require("../../ultramodern-workspace/contracts.cjs");
-const descriptors_cjs_namespaceObject = require("../../ultramodern-workspace/descriptors.cjs");
-const patch_parity_cjs_namespaceObject = require("../../ultramodern-workspace/patch-parity.cjs");
-const workspace_scripts_cjs_namespaceObject = require("../../ultramodern-workspace/workspace-scripts.cjs");
+const workspace_cjs_namespaceObject = require("../../ultramodern-workspace/validation/workspace.cjs");
+const workspace_validation_contract_cjs_namespaceObject = require("../../ultramodern-workspace/workspace-validation-contract.cjs");
 const external_config_cjs_namespaceObject = require("../config.cjs");
-const external_context_cjs_namespaceObject = require("./context.cjs");
-function runValidate(context) {
-    const patchProblems = (0, patch_parity_cjs_namespaceObject.checkPatchParity)({
-        workspaceRoot: context.workspaceRoot,
-        createPackageRoot: external_context_cjs_namespaceObject.createPackageRoot
-    });
-    if (patchProblems.length > 0) {
-        process.stderr.write(`${(0, patch_parity_cjs_namespaceObject.formatPatchParityReport)(patchProblems)}\n`);
-        return 1;
-    }
-    const workspace = (0, external_config_cjs_namespaceObject.readUltramodernWorkspaceInputs)(context.workspaceRoot, {
-        overlay: (0, external_config_cjs_namespaceObject.readJsonObject)(external_node_path_default().join(context.workspaceRoot, 'topology/local-overlays/development.json'))
+async function runValidate(context) {
+    const { config, raw, verticals, primaryShell, additionalShells } = await (0, external_config_cjs_namespaceObject.readResolvedUltramodernWorkspaceInputs)(context.workspaceRoot, {}, {
+        command: 'validate',
+        env: 'development'
     });
-    const { config, verticals: remotes, primaryShell, additionalShells } = workspace;
-    const compactApps = (0, external_config_cjs_namespaceObject.workspaceAppsFromToolingConfig)(config, context.workspaceRoot);
-    const compactPrimaryShell = compactApps.find((app)=>'shell' === app.kind) ?? (0, descriptors_cjs_namespaceObject.createShellHost)(remotes);
-    const compactConfig = (0, contracts_cjs_namespaceObject.createUltramodernConfig)(config.workspace.packageScope, 'workspace-validation-contract', {
-        strategy: 'workspace',
-        modernPackageVersion: 'workspace:*'
-    }, compactApps, config.features.tailwind, void 0, additionalShells, compactPrimaryShell, remotes);
-    const declaredCompact = (0, external_config_cjs_namespaceObject.readJsonObject)(config.sourcePath);
-    const compactTopology = compactConfig.topology;
-    for (const app of compactTopology.apps){
-        const declared = declaredCompact.topology?.apps?.find((entry)=>entry.id === app.id)?.deploy?.cloudflare;
-        for (const key of [
-            'routes',
-            'distributedSsrProofRoutes',
-            'jsonSmokeChecks'
-        ])if (declared && Object.hasOwn(declared, key)) app.deploy.cloudflare[key] = declared[key];
-    }
-    const releaseCohort = config.packageSource?.strategy === 'install' ? (0, external_ultramodern_release_cohort_cjs_namespaceObject.readWorkspaceReleaseCohort)(context.workspaceRoot) : void 0;
-    const source = (0, workspace_scripts_cjs_namespaceObject.createPackagedWorkspaceValidationScript)(config.workspace.packageScope, config.features.tailwind, remotes, releaseCohort, additionalShells, primaryShell, compactConfig, (0, external_config_cjs_namespaceObject.readJsonObject)(external_node_path_default().join(context.workspaceRoot, 'topology/ownership.json')), void 0, context.workspaceRoot);
-    return (0, external_context_cjs_namespaceObject.runRenderedModule)(source, context);
+    (0, workspace_cjs_namespaceObject.validateWorkspace)(context.workspaceRoot, (0, workspace_validation_contract_cjs_namespaceObject.createWorkspaceValidationContract)(config.workspace.packageScope, config.features.tailwind, raw.topology.sharedPackages, verticals, additionalShells, primaryShell));
+    return 0;
 }
 exports.runValidate = __webpack_exports__.runValidate;
 for(var __rspack_i in __webpack_exports__)if (-1 === [

package/dist/cjs/ultramodern-tooling/commands.cjs

@@ -39,6 +39,8 @@ __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
     runUltramodernToolingCli: ()=>runUltramodernToolingCli
 });
+const external_node_fs_namespaceObject = require("node:fs");
+var external_node_fs_default = /*#__PURE__*/ __webpack_require__.n(external_node_fs_namespaceObject);
 const external_node_path_namespaceObject = require("node:path");
 var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
 const tooling_command_catalog_cjs_namespaceObject = require("../ultramodern-workspace/tooling-command-catalog.cjs");
@@ -52,8 +54,16 @@ const validate_cjs_namespaceObject = require("./commands/validate.cjs");
 async function runUltramodernToolingCli(args, workspaceRoot = process.env.ULTRAMODERN_WORKSPACE_ROOT ?? process.cwd()) {
     try {
         const [command, ...rest] = args;
+        let discoveredRoot = external_node_path_default().resolve(workspaceRoot);
+        for(let candidate = discoveredRoot;; candidate = external_node_path_default().dirname(candidate)){
+            if (external_node_fs_default().existsSync(external_node_path_default().join(candidate, 'topology/reference-topology.json'))) {
+                discoveredRoot = candidate;
+                break;
+            }
+            if (external_node_path_default().dirname(candidate) === candidate) break;
+        }
         const context = {
-            workspaceRoot: external_node_path_default().resolve(workspaceRoot),
+            workspaceRoot: discoveredRoot,
             invocationCwd: process.cwd()
         };
         switch(command){
@@ -67,9 +77,9 @@ async function runUltramodernToolingCli(args, workspaceRoot = process.env.ULTRAM
             case tooling_command_catalog_cjs_namespaceObject.GENERATED_TOOLING_COMMANDS.mfTypes.command:
                 return (0, mf_types_cjs_namespaceObject.runMfTypes)(rest, context);
             case tooling_command_catalog_cjs_namespaceObject.GENERATED_TOOLING_COMMANDS.cloudflareOutputVerify.command:
-                return (0, cloudflare_output_verify_cjs_namespaceObject.runCloudflareOutputVerify)(rest, context);
+                return await (0, cloudflare_output_verify_cjs_namespaceObject.runCloudflareOutputVerify)(rest, context);
             case tooling_command_catalog_cjs_namespaceObject.GENERATED_TOOLING_COMMANDS.routesGenerate.command:
-                return (0, routes_generate_cjs_namespaceObject.runRoutesGenerate)(rest, context);
+                return await (0, routes_generate_cjs_namespaceObject.runRoutesGenerate)(rest, context);
             case context_cjs_namespaceObject.AD_HOC_TOOLING_COMMANDS.syncDeliveryUnit:
                 return (0, sync_delivery_unit_cjs_namespaceObject.runSyncDeliveryUnit)(rest, context);
             case context_cjs_namespaceObject.AD_HOC_TOOLING_COMMANDS.skills:

package/dist/cjs/ultramodern-tooling/config/index.cjs

@@ -6,6 +6,9 @@ var __webpack_modules__ = {
     "./load" (module) {
         module.exports = require("./load.cjs");
     },
+    "./metadata" (module) {
+        module.exports = require("./metadata.cjs");
+    },
     "./normalize" (module) {
         module.exports = require("./normalize.cjs");
     },
@@ -68,13 +71,17 @@ var __webpack_exports__ = {};
     var __rspack_reexport = {};
     for(const __rspack_import_key in _load__rspack_import_1)if ("default" !== __rspack_import_key) __rspack_reexport[__rspack_import_key] = ()=>_load__rspack_import_1[__rspack_import_key];
     __webpack_require__.d(__webpack_exports__, __rspack_reexport);
-    var _normalize__rspack_import_2 = __webpack_require__("./normalize");
+    var _metadata__rspack_import_2 = __webpack_require__("./metadata");
+    var __rspack_reexport = {};
+    for(const __rspack_import_key in _metadata__rspack_import_2)if ("default" !== __rspack_import_key) __rspack_reexport[__rspack_import_key] = ()=>_metadata__rspack_import_2[__rspack_import_key];
+    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+    var _normalize__rspack_import_3 = __webpack_require__("./normalize");
     var __rspack_reexport = {};
-    for(const __rspack_import_key in _normalize__rspack_import_2)if ("default" !== __rspack_import_key) __rspack_reexport[__rspack_import_key] = ()=>_normalize__rspack_import_2[__rspack_import_key];
+    for(const __rspack_import_key in _normalize__rspack_import_3)if ("default" !== __rspack_import_key) __rspack_reexport[__rspack_import_key] = ()=>_normalize__rspack_import_3[__rspack_import_key];
     __webpack_require__.d(__webpack_exports__, __rspack_reexport);
-    var _types__rspack_import_3 = __webpack_require__("./types");
+    var _types__rspack_import_4 = __webpack_require__("./types");
     var __rspack_reexport = {};
-    for(const __rspack_import_key in _types__rspack_import_3)if ("default" !== __rspack_import_key) __rspack_reexport[__rspack_import_key] = ()=>_types__rspack_import_3[__rspack_import_key];
+    for(const __rspack_import_key in _types__rspack_import_4)if ("default" !== __rspack_import_key) __rspack_reexport[__rspack_import_key] = ()=>_types__rspack_import_4[__rspack_import_key];
     __webpack_require__.d(__webpack_exports__, __rspack_reexport);
 })();
 for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];