@bleedingdev/modern-js-plugin-tanstack 3.9.0-ultramodern.17 → 3.9.0-ultramodern.18

package/dist/cjs/cli/artifacts.js

@@ -38,12 +38,14 @@ var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
     generateTanstackRouteArtifacts: ()=>generateTanstackRouteArtifacts,
+    writeRouteMetadataManifest: ()=>writeRouteMetadataManifest,
     writeTanstackRegisterFile: ()=>writeTanstackRegisterFile,
     writeTanstackRouterTypesForEntries: ()=>writeTanstackRouterTypesForEntries
 });
 const external_node_path_namespaceObject = require("node:path");
 var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
 const utils_namespaceObject = require("@modern-js/utils");
+const external_routeMetadata_js_namespaceObject = require("./routeMetadata.js");
 const external_tanstackTypes_js_namespaceObject = require("./tanstackTypes.js");
 const DEFAULT_GENERATED_DIR_NAME = 'modern-tanstack';
 async function writeFileIfChanged(filePath, content) {
@@ -121,7 +123,16 @@ async function writeTanstackRouterTypesForEntries(opts) {
         canonicalRoutes
     });
 }
+async function writeRouteMetadataManifest(opts) {
+    const routesDirectory = external_node_path_default().join(opts.appDirectory, 'src', 'routes');
+    const manifestPath = external_node_path_default().join(routesDirectory, external_routeMetadata_js_namespaceObject.ROUTE_METADATA_MANIFEST_FILE_NAME);
+    const manifest = (0, external_routeMetadata_js_namespaceObject.renderRouteMetadataManifest)(await (0, external_routeMetadata_js_namespaceObject.findRouteMetaFiles)(routesDirectory));
+    if (null !== manifest) return void await writeFileIfChanged(manifestPath, manifest);
+    const previous = await utils_namespaceObject.fs.pathExists(manifestPath) ? await utils_namespaceObject.fs.readFile(manifestPath, 'utf-8') : null;
+    if (previous?.startsWith(`${external_routeMetadata_js_namespaceObject.ROUTE_METADATA_MANIFEST_HEADER}\n`)) throw new Error(`[plugin-tanstack] ${manifestPath} is generated from route.meta.ts files, but none remain below ${routesDirectory}. Restore at least one route.meta.ts that exports routeMeta, or delete the manifest together with its imports.`);
+}
 async function generateTanstackRouteArtifacts(opts) {
+    await writeRouteMetadataManifest(opts);
     const [{ createRunOptions }, { cli }, utils] = await Promise.all([
         import("@modern-js/app-tools/cli/run"),
         import("@modern-js/plugin/cli"),
@@ -146,10 +157,12 @@ async function generateTanstackRouteArtifacts(opts) {
     await appContext.hooks.onBeforeExit.call();
 }
 exports.generateTanstackRouteArtifacts = __webpack_exports__.generateTanstackRouteArtifacts;
+exports.writeRouteMetadataManifest = __webpack_exports__.writeRouteMetadataManifest;
 exports.writeTanstackRegisterFile = __webpack_exports__.writeTanstackRegisterFile;
 exports.writeTanstackRouterTypesForEntries = __webpack_exports__.writeTanstackRouterTypesForEntries;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
     "generateTanstackRouteArtifacts",
+    "writeRouteMetadataManifest",
     "writeTanstackRegisterFile",
     "writeTanstackRouterTypesForEntries"
 ].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];

package/dist/cjs/cli/index.js

@@ -59,6 +59,7 @@ var __webpack_exports__ = {};
         generateTanstackRouterTypesSourceForEntry: ()=>external_tanstackTypes_js_namespaceObject.generateTanstackRouterTypesSourceForEntry,
         resolveTanstackRouteCodeSplittingEnabled: ()=>external_routeSplitting_js_namespaceObject.resolveTanstackRouteCodeSplittingEnabled,
         tanstackRouterPlugin: ()=>tanstackRouterPlugin,
+        writeRouteMetadataManifest: ()=>external_artifacts_js_namespaceObject.writeRouteMetadataManifest,
         writeTanstackRegisterFile: ()=>external_artifacts_js_namespaceObject.writeTanstackRegisterFile,
         writeTanstackRouterTypesForEntries: ()=>external_artifacts_js_namespaceObject.writeTanstackRouterTypesForEntries
     });
@@ -248,6 +249,7 @@ exports.generateTanstackRouteArtifacts = __webpack_exports__.generateTanstackRou
 exports.generateTanstackRouterTypesSourceForEntry = __webpack_exports__.generateTanstackRouterTypesSourceForEntry;
 exports.resolveTanstackRouteCodeSplittingEnabled = __webpack_exports__.resolveTanstackRouteCodeSplittingEnabled;
 exports.tanstackRouterPlugin = __webpack_exports__.tanstackRouterPlugin;
+exports.writeRouteMetadataManifest = __webpack_exports__.writeRouteMetadataManifest;
 exports.writeTanstackRegisterFile = __webpack_exports__.writeTanstackRegisterFile;
 exports.writeTanstackRouterTypesForEntries = __webpack_exports__.writeTanstackRouterTypesForEntries;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
@@ -258,6 +260,7 @@ for(var __rspack_i in __webpack_exports__)if (-1 === [
     "generateTanstackRouterTypesSourceForEntry",
     "resolveTanstackRouteCodeSplittingEnabled",
     "tanstackRouterPlugin",
+    "writeRouteMetadataManifest",
     "writeTanstackRegisterFile",
     "writeTanstackRouterTypesForEntries"
 ].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];

package/dist/cjs/cli/routeMetadata.js

@@ -0,0 +1,131 @@
+"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);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    ROUTE_METADATA_MANIFEST_FILE_NAME: ()=>ROUTE_METADATA_MANIFEST_FILE_NAME,
+    ROUTE_METADATA_MANIFEST_HEADER: ()=>ROUTE_METADATA_MANIFEST_HEADER,
+    ROUTE_META_FILE_NAME: ()=>ROUTE_META_FILE_NAME,
+    findRouteMetaFiles: ()=>findRouteMetaFiles,
+    renderRouteMetadataManifest: ()=>renderRouteMetadataManifest
+});
+const promises_namespaceObject = require("node:fs/promises");
+const external_node_path_namespaceObject = require("node:path");
+var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
+const ROUTE_META_FILE_NAME = 'route.meta.ts';
+const ROUTE_METADATA_MANIFEST_FILE_NAME = 'ultramodern-route-metadata.ts';
+const ROUTE_METADATA_MANIFEST_HEADER = `// @generated by @modern-js/plugin-tanstack from ${ROUTE_META_FILE_NAME} files. Run routes-generate; do not edit.`;
+const PRINT_WIDTH = 120;
+const MANIFEST_BODY = `export const ultramodernLocalisedUrls = Object.fromEntries(
+  ultramodernRouteMetadata
+    .filter((route) => route.canonicalPath !== '/')
+    .map((route) => [route.canonicalPath, route.localisedPaths]),
+);
+export const ultramodernPublicRoutes = ultramodernRouteMetadata
+  .filter((route) => route.public && route.indexable)
+  .map((route) => ({
+    canonicalPath: route.canonicalPath,
+    descriptionKey: route.descriptionKey,
+    id: route.id,
+    localisedPaths: route.localisedPaths,
+    namespace: route.namespace,
+    ownerAppId: route.ownerAppId,
+    titleKey: route.titleKey,
+    ...('jsonLd' in route ? { jsonLd: route.jsonLd } : {}),
+  }));
+export const ultramodernRouteConfig = {
+  authoring: 'colocated-route-meta',
+  generatedManifest: true,
+  localisedUrls: ultramodernLocalisedUrls,
+  namespace: ultramodernRouteNamespace,
+  publicRoutes: ultramodernPublicRoutes,
+  routes: ultramodernRouteMetadata,
+  source: 'route-owned',
+} as const;
+`;
+const compareCodeUnits = (left, right)=>left < right ? -1 : left > right ? 1 : 0;
+const quoteSpecifier = (specifier)=>specifier.includes("'") ? JSON.stringify(specifier) : `'${specifier}'`;
+function renderRouteMetadataManifest(routeMetaFiles) {
+    const specifiers = routeMetaFiles.map((file)=>`./${file.replaceAll('\\', '/').replace(/\.ts$/u, '')}`).sort(compareCodeUnits);
+    if (0 === specifiers.length) return null;
+    const bindings = specifiers.map((_, index)=>`route${index}`);
+    const imports = specifiers.map((specifier, index)=>`import { routeMeta as ${bindings[index]} } from ${quoteSpecifier(specifier)};`);
+    const inlineRoutes = `export const ultramodernRouteMetadata = [${bindings.join(', ')}] as const;`;
+    const routes = inlineRoutes.length <= PRINT_WIDTH ? inlineRoutes : `export const ultramodernRouteMetadata = [\n${bindings.map((binding)=>`  ${binding},\n`).join('')}] as const;`;
+    return `${ROUTE_METADATA_MANIFEST_HEADER}
+${imports.join('\n')}
+
+export const ultramodernRouteNamespace = route0.namespace;
+${routes}
+${MANIFEST_BODY}`;
+}
+async function findRouteMetaFiles(routesDirectory) {
+    const files = [];
+    const visit = async (relativeDirectory)=>{
+        const entries = await (0, promises_namespaceObject.readdir)(external_node_path_default().join(routesDirectory, relativeDirectory), {
+            withFileTypes: true
+        });
+        for (const entry of entries){
+            const relativePath = external_node_path_default().join(relativeDirectory, entry.name);
+            if (entry.isDirectory()) await visit(relativePath);
+            else if (entry.isFile() && entry.name === ROUTE_META_FILE_NAME) files.push(relativePath);
+        }
+    };
+    try {
+        await visit('');
+    } catch (error) {
+        const { code, path: missingPath } = error;
+        if ('ENOENT' === code && missingPath === routesDirectory) return [];
+        throw error;
+    }
+    return files;
+}
+exports.ROUTE_METADATA_MANIFEST_FILE_NAME = __webpack_exports__.ROUTE_METADATA_MANIFEST_FILE_NAME;
+exports.ROUTE_METADATA_MANIFEST_HEADER = __webpack_exports__.ROUTE_METADATA_MANIFEST_HEADER;
+exports.ROUTE_META_FILE_NAME = __webpack_exports__.ROUTE_META_FILE_NAME;
+exports.findRouteMetaFiles = __webpack_exports__.findRouteMetaFiles;
+exports.renderRouteMetadataManifest = __webpack_exports__.renderRouteMetadataManifest;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "ROUTE_METADATA_MANIFEST_FILE_NAME",
+    "ROUTE_METADATA_MANIFEST_HEADER",
+    "ROUTE_META_FILE_NAME",
+    "findRouteMetaFiles",
+    "renderRouteMetadataManifest"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/esm/cli/artifacts.mjs

@@ -1,5 +1,6 @@
 import node_path from "node:path";
 import { fs } from "@modern-js/utils";
+import { ROUTE_METADATA_MANIFEST_FILE_NAME, ROUTE_METADATA_MANIFEST_HEADER, findRouteMetaFiles, renderRouteMetadataManifest } from "./routeMetadata.mjs";
 import { collectCanonicalRoutesForEntry, generateTanstackRouterTypesSourceForEntry } from "./tanstackTypes.mjs";
 const DEFAULT_GENERATED_DIR_NAME = 'modern-tanstack';
 async function writeFileIfChanged(filePath, content) {
@@ -77,7 +78,16 @@ async function writeTanstackRouterTypesForEntries(opts) {
         canonicalRoutes
     });
 }
+async function writeRouteMetadataManifest(opts) {
+    const routesDirectory = node_path.join(opts.appDirectory, 'src', 'routes');
+    const manifestPath = node_path.join(routesDirectory, ROUTE_METADATA_MANIFEST_FILE_NAME);
+    const manifest = renderRouteMetadataManifest(await findRouteMetaFiles(routesDirectory));
+    if (null !== manifest) return void await writeFileIfChanged(manifestPath, manifest);
+    const previous = await fs.pathExists(manifestPath) ? await fs.readFile(manifestPath, 'utf-8') : null;
+    if (previous?.startsWith(`${ROUTE_METADATA_MANIFEST_HEADER}\n`)) throw new Error(`[plugin-tanstack] ${manifestPath} is generated from route.meta.ts files, but none remain below ${routesDirectory}. Restore at least one route.meta.ts that exports routeMeta, or delete the manifest together with its imports.`);
+}
 async function generateTanstackRouteArtifacts(opts) {
+    await writeRouteMetadataManifest(opts);
     const [{ createRunOptions }, { cli }, utils] = await Promise.all([
         import("@modern-js/app-tools/cli/run"),
         import("@modern-js/plugin/cli"),
@@ -101,4 +111,4 @@ async function generateTanstackRouteArtifacts(opts) {
     });
     await appContext.hooks.onBeforeExit.call();
 }
-export { generateTanstackRouteArtifacts, writeTanstackRegisterFile, writeTanstackRouterTypesForEntries };
+export { generateTanstackRouteArtifacts, writeRouteMetadataManifest, writeTanstackRegisterFile, writeTanstackRouterTypesForEntries };

package/dist/esm/cli/index.mjs

@@ -1,6 +1,6 @@
 import node_path from "node:path";
 import { NESTED_ROUTE_SPEC_FILE, filterRoutesForServer } from "@modern-js/utils";
-import { generateTanstackRouteArtifacts, writeTanstackRegisterFile, writeTanstackRouterTypesForEntries } from "./artifacts.mjs";
+import { generateTanstackRouteArtifacts, writeRouteMetadataManifest, writeTanstackRegisterFile, writeTanstackRouterTypesForEntries } from "./artifacts.mjs";
 import { createTanstackRsbuildRouteSplittingProfile, resolveTanstackRouteCodeSplittingEnabled } from "./routeSplitting.mjs";
 const DEFAULT_ROUTES_DIR = 'routes';
 const DEFAULT_GENERATED_DIR_NAME = 'modern-tanstack';
@@ -176,4 +176,4 @@ function tanstackRouterPlugin(options = {}) {
 const src_cli = tanstackRouterPlugin;
 export { collectCanonicalRoutesForEntry, generateTanstackRouterTypesSourceForEntry } from "./tanstackTypes.mjs";
 export default src_cli;
-export { createTanstackRsbuildRouteSplittingProfile, generateTanstackRouteArtifacts, resolveTanstackRouteCodeSplittingEnabled, tanstackRouterPlugin, writeTanstackRegisterFile, writeTanstackRouterTypesForEntries };
+export { createTanstackRsbuildRouteSplittingProfile, generateTanstackRouteArtifacts, resolveTanstackRouteCodeSplittingEnabled, tanstackRouterPlugin, writeRouteMetadataManifest, writeTanstackRegisterFile, writeTanstackRouterTypesForEntries };

package/dist/esm/cli/routeMetadata.mjs

@@ -0,0 +1,71 @@
+import { readdir } from "node:fs/promises";
+import node_path from "node:path";
+const ROUTE_META_FILE_NAME = 'route.meta.ts';
+const ROUTE_METADATA_MANIFEST_FILE_NAME = 'ultramodern-route-metadata.ts';
+const ROUTE_METADATA_MANIFEST_HEADER = `// @generated by @modern-js/plugin-tanstack from ${ROUTE_META_FILE_NAME} files. Run routes-generate; do not edit.`;
+const PRINT_WIDTH = 120;
+const MANIFEST_BODY = `export const ultramodernLocalisedUrls = Object.fromEntries(
+  ultramodernRouteMetadata
+    .filter((route) => route.canonicalPath !== '/')
+    .map((route) => [route.canonicalPath, route.localisedPaths]),
+);
+export const ultramodernPublicRoutes = ultramodernRouteMetadata
+  .filter((route) => route.public && route.indexable)
+  .map((route) => ({
+    canonicalPath: route.canonicalPath,
+    descriptionKey: route.descriptionKey,
+    id: route.id,
+    localisedPaths: route.localisedPaths,
+    namespace: route.namespace,
+    ownerAppId: route.ownerAppId,
+    titleKey: route.titleKey,
+    ...('jsonLd' in route ? { jsonLd: route.jsonLd } : {}),
+  }));
+export const ultramodernRouteConfig = {
+  authoring: 'colocated-route-meta',
+  generatedManifest: true,
+  localisedUrls: ultramodernLocalisedUrls,
+  namespace: ultramodernRouteNamespace,
+  publicRoutes: ultramodernPublicRoutes,
+  routes: ultramodernRouteMetadata,
+  source: 'route-owned',
+} as const;
+`;
+const compareCodeUnits = (left, right)=>left < right ? -1 : left > right ? 1 : 0;
+const quoteSpecifier = (specifier)=>specifier.includes("'") ? JSON.stringify(specifier) : `'${specifier}'`;
+function renderRouteMetadataManifest(routeMetaFiles) {
+    const specifiers = routeMetaFiles.map((file)=>`./${file.replaceAll('\\', '/').replace(/\.ts$/u, '')}`).sort(compareCodeUnits);
+    if (0 === specifiers.length) return null;
+    const bindings = specifiers.map((_, index)=>`route${index}`);
+    const imports = specifiers.map((specifier, index)=>`import { routeMeta as ${bindings[index]} } from ${quoteSpecifier(specifier)};`);
+    const inlineRoutes = `export const ultramodernRouteMetadata = [${bindings.join(', ')}] as const;`;
+    const routes = inlineRoutes.length <= PRINT_WIDTH ? inlineRoutes : `export const ultramodernRouteMetadata = [\n${bindings.map((binding)=>`  ${binding},\n`).join('')}] as const;`;
+    return `${ROUTE_METADATA_MANIFEST_HEADER}
+${imports.join('\n')}
+
+export const ultramodernRouteNamespace = route0.namespace;
+${routes}
+${MANIFEST_BODY}`;
+}
+async function findRouteMetaFiles(routesDirectory) {
+    const files = [];
+    const visit = async (relativeDirectory)=>{
+        const entries = await readdir(node_path.join(routesDirectory, relativeDirectory), {
+            withFileTypes: true
+        });
+        for (const entry of entries){
+            const relativePath = node_path.join(relativeDirectory, entry.name);
+            if (entry.isDirectory()) await visit(relativePath);
+            else if (entry.isFile() && entry.name === ROUTE_META_FILE_NAME) files.push(relativePath);
+        }
+    };
+    try {
+        await visit('');
+    } catch (error) {
+        const { code, path: missingPath } = error;
+        if ('ENOENT' === code && missingPath === routesDirectory) return [];
+        throw error;
+    }
+    return files;
+}
+export { ROUTE_METADATA_MANIFEST_FILE_NAME, ROUTE_METADATA_MANIFEST_HEADER, ROUTE_META_FILE_NAME, findRouteMetaFiles, renderRouteMetadataManifest };

package/dist/esm-node/cli/artifacts.mjs

@@ -1,6 +1,7 @@
 import "node:module";
 import node_path from "node:path";
 import { fs } from "@modern-js/utils";
+import { ROUTE_METADATA_MANIFEST_FILE_NAME, ROUTE_METADATA_MANIFEST_HEADER, findRouteMetaFiles, renderRouteMetadataManifest } from "./routeMetadata.mjs";
 import { collectCanonicalRoutesForEntry, generateTanstackRouterTypesSourceForEntry } from "./tanstackTypes.mjs";
 const DEFAULT_GENERATED_DIR_NAME = 'modern-tanstack';
 async function writeFileIfChanged(filePath, content) {
@@ -78,7 +79,16 @@ async function writeTanstackRouterTypesForEntries(opts) {
         canonicalRoutes
     });
 }
+async function writeRouteMetadataManifest(opts) {
+    const routesDirectory = node_path.join(opts.appDirectory, 'src', 'routes');
+    const manifestPath = node_path.join(routesDirectory, ROUTE_METADATA_MANIFEST_FILE_NAME);
+    const manifest = renderRouteMetadataManifest(await findRouteMetaFiles(routesDirectory));
+    if (null !== manifest) return void await writeFileIfChanged(manifestPath, manifest);
+    const previous = await fs.pathExists(manifestPath) ? await fs.readFile(manifestPath, 'utf-8') : null;
+    if (previous?.startsWith(`${ROUTE_METADATA_MANIFEST_HEADER}\n`)) throw new Error(`[plugin-tanstack] ${manifestPath} is generated from route.meta.ts files, but none remain below ${routesDirectory}. Restore at least one route.meta.ts that exports routeMeta, or delete the manifest together with its imports.`);
+}
 async function generateTanstackRouteArtifacts(opts) {
+    await writeRouteMetadataManifest(opts);
     const [{ createRunOptions }, { cli }, utils] = await Promise.all([
         import("@modern-js/app-tools/cli/run"),
         import("@modern-js/plugin/cli"),
@@ -102,4 +112,4 @@ async function generateTanstackRouteArtifacts(opts) {
     });
     await appContext.hooks.onBeforeExit.call();
 }
-export { generateTanstackRouteArtifacts, writeTanstackRegisterFile, writeTanstackRouterTypesForEntries };
+export { generateTanstackRouteArtifacts, writeRouteMetadataManifest, writeTanstackRegisterFile, writeTanstackRouterTypesForEntries };

package/dist/esm-node/cli/index.mjs

@@ -1,7 +1,7 @@
 import "node:module";
 import node_path from "node:path";
 import { NESTED_ROUTE_SPEC_FILE, filterRoutesForServer } from "@modern-js/utils";
-import { generateTanstackRouteArtifacts, writeTanstackRegisterFile, writeTanstackRouterTypesForEntries } from "./artifacts.mjs";
+import { generateTanstackRouteArtifacts, writeRouteMetadataManifest, writeTanstackRegisterFile, writeTanstackRouterTypesForEntries } from "./artifacts.mjs";
 import { createTanstackRsbuildRouteSplittingProfile, resolveTanstackRouteCodeSplittingEnabled } from "./routeSplitting.mjs";
 import { fileURLToPath as __rspack_fileURLToPath } from "node:url";
 import { dirname as __rspack_dirname } from "node:path";
@@ -182,4 +182,4 @@ function tanstackRouterPlugin(options = {}) {
 const src_cli = tanstackRouterPlugin;
 export { collectCanonicalRoutesForEntry, generateTanstackRouterTypesSourceForEntry } from "./tanstackTypes.mjs";
 export default src_cli;
-export { createTanstackRsbuildRouteSplittingProfile, generateTanstackRouteArtifacts, resolveTanstackRouteCodeSplittingEnabled, tanstackRouterPlugin, writeTanstackRegisterFile, writeTanstackRouterTypesForEntries };
+export { createTanstackRsbuildRouteSplittingProfile, generateTanstackRouteArtifacts, resolveTanstackRouteCodeSplittingEnabled, tanstackRouterPlugin, writeRouteMetadataManifest, writeTanstackRegisterFile, writeTanstackRouterTypesForEntries };

package/dist/esm-node/cli/routeMetadata.mjs

@@ -0,0 +1,72 @@
+import "node:module";
+import { readdir } from "node:fs/promises";
+import node_path from "node:path";
+const ROUTE_META_FILE_NAME = 'route.meta.ts';
+const ROUTE_METADATA_MANIFEST_FILE_NAME = 'ultramodern-route-metadata.ts';
+const ROUTE_METADATA_MANIFEST_HEADER = `// @generated by @modern-js/plugin-tanstack from ${ROUTE_META_FILE_NAME} files. Run routes-generate; do not edit.`;
+const PRINT_WIDTH = 120;
+const MANIFEST_BODY = `export const ultramodernLocalisedUrls = Object.fromEntries(
+  ultramodernRouteMetadata
+    .filter((route) => route.canonicalPath !== '/')
+    .map((route) => [route.canonicalPath, route.localisedPaths]),
+);
+export const ultramodernPublicRoutes = ultramodernRouteMetadata
+  .filter((route) => route.public && route.indexable)
+  .map((route) => ({
+    canonicalPath: route.canonicalPath,
+    descriptionKey: route.descriptionKey,
+    id: route.id,
+    localisedPaths: route.localisedPaths,
+    namespace: route.namespace,
+    ownerAppId: route.ownerAppId,
+    titleKey: route.titleKey,
+    ...('jsonLd' in route ? { jsonLd: route.jsonLd } : {}),
+  }));
+export const ultramodernRouteConfig = {
+  authoring: 'colocated-route-meta',
+  generatedManifest: true,
+  localisedUrls: ultramodernLocalisedUrls,
+  namespace: ultramodernRouteNamespace,
+  publicRoutes: ultramodernPublicRoutes,
+  routes: ultramodernRouteMetadata,
+  source: 'route-owned',
+} as const;
+`;
+const compareCodeUnits = (left, right)=>left < right ? -1 : left > right ? 1 : 0;
+const quoteSpecifier = (specifier)=>specifier.includes("'") ? JSON.stringify(specifier) : `'${specifier}'`;
+function renderRouteMetadataManifest(routeMetaFiles) {
+    const specifiers = routeMetaFiles.map((file)=>`./${file.replaceAll('\\', '/').replace(/\.ts$/u, '')}`).sort(compareCodeUnits);
+    if (0 === specifiers.length) return null;
+    const bindings = specifiers.map((_, index)=>`route${index}`);
+    const imports = specifiers.map((specifier, index)=>`import { routeMeta as ${bindings[index]} } from ${quoteSpecifier(specifier)};`);
+    const inlineRoutes = `export const ultramodernRouteMetadata = [${bindings.join(', ')}] as const;`;
+    const routes = inlineRoutes.length <= PRINT_WIDTH ? inlineRoutes : `export const ultramodernRouteMetadata = [\n${bindings.map((binding)=>`  ${binding},\n`).join('')}] as const;`;
+    return `${ROUTE_METADATA_MANIFEST_HEADER}
+${imports.join('\n')}
+
+export const ultramodernRouteNamespace = route0.namespace;
+${routes}
+${MANIFEST_BODY}`;
+}
+async function findRouteMetaFiles(routesDirectory) {
+    const files = [];
+    const visit = async (relativeDirectory)=>{
+        const entries = await readdir(node_path.join(routesDirectory, relativeDirectory), {
+            withFileTypes: true
+        });
+        for (const entry of entries){
+            const relativePath = node_path.join(relativeDirectory, entry.name);
+            if (entry.isDirectory()) await visit(relativePath);
+            else if (entry.isFile() && entry.name === ROUTE_META_FILE_NAME) files.push(relativePath);
+        }
+    };
+    try {
+        await visit('');
+    } catch (error) {
+        const { code, path: missingPath } = error;
+        if ('ENOENT' === code && missingPath === routesDirectory) return [];
+        throw error;
+    }
+    return files;
+}
+export { ROUTE_METADATA_MANIFEST_FILE_NAME, ROUTE_METADATA_MANIFEST_HEADER, ROUTE_META_FILE_NAME, findRouteMetaFiles, renderRouteMetadataManifest };

package/dist/types/cli/artifacts.d.ts

@@ -21,11 +21,19 @@ export declare function writeTanstackRouterTypesForEntries(opts: {
     i18nPluginInstalled?: boolean;
 }): Promise<void>;
 /**
- * Headless regeneration of `router.gen.ts` / `register.gen.d.ts` for a generated
- * app, without running a full dev/build. Drives the app-tools analyze `onPrepare`
- * (which fires `generateEntryCode`) and returns before any bundling — the app's
- * own registered plugin-tanstack writes the artifacts via its `generateEntryCode`
- * subscriber. Reuses the exact hook dev/build use, so there is no scanning drift.
+ * Writes `src/routes/ultramodern-route-metadata.ts` from the `route.meta.ts`
+ * files below `src/routes`. Reads only the file system, never the app config.
+ */
+export declare function writeRouteMetadataManifest(opts: {
+    appDirectory: string;
+}): Promise<void>;
+/**
+ * Headless regeneration of the route metadata manifest and of `router.gen.ts` /
+ * `register.gen.d.ts` for a generated app, without running a full dev/build.
+ * Drives the app-tools analyze `onPrepare` (which fires `generateEntryCode`)
+ * and returns before any bundling — the app's own registered plugin-tanstack
+ * writes the router artifacts via its `generateEntryCode` subscriber. Reuses
+ * the exact hook dev/build use, so there is no scanning drift.
  */
 export declare function generateTanstackRouteArtifacts(opts: {
     appDirectory: string;

package/dist/types/cli/index.d.ts

@@ -1,6 +1,6 @@
 import type { AppTools, CliPlugin } from '@modern-js/app-tools';
 import { type TanstackRouteCodeSplittingOption } from './routeSplitting.js';
-export { generateTanstackRouteArtifacts, writeTanstackRegisterFile, writeTanstackRouterTypesForEntries, } from './artifacts.js';
+export { generateTanstackRouteArtifacts, writeRouteMetadataManifest, writeTanstackRegisterFile, writeTanstackRouterTypesForEntries, } from './artifacts.js';
 export type { TanstackRouteCodeSplittingOption, TanstackRsbuildRouteSplittingProfile, } from './routeSplitting.js';
 export { createTanstackRsbuildRouteSplittingProfile, resolveTanstackRouteCodeSplittingEnabled, } from './routeSplitting.js';
 export { type CollectCanonicalRoutesOptions, collectCanonicalRoutesForEntry, generateTanstackRouterTypesSourceForEntry, } from './tanstackTypes.js';

package/dist/types/cli/routeMetadata.d.ts

@@ -0,0 +1,18 @@
+export declare const ROUTE_META_FILE_NAME = "route.meta.ts";
+export declare const ROUTE_METADATA_MANIFEST_FILE_NAME = "ultramodern-route-metadata.ts";
+export declare const ROUTE_METADATA_MANIFEST_HEADER = "// @generated by @modern-js/plugin-tanstack from route.meta.ts files. Run routes-generate; do not edit.";
+/**
+ * Renders the route metadata manifest for the `route.meta.ts` files of one
+ * routes directory. Each path is relative to that directory (either separator).
+ * Every `route.meta.ts` must export `routeMeta`; the manifest imports it
+ * statically, so the metadata is never evaluated while generating. Returns
+ * `null` when there are no route metadata files. Output depends only on the
+ * set of paths, never on their order or on the file system.
+ */
+export declare function renderRouteMetadataManifest(routeMetaFiles: readonly string[]): string | null;
+/**
+ * Lists the `route.meta.ts` files below `routesDirectory`, relative to it.
+ * Symbolic links are not followed: linked metadata belongs to the tree it
+ * lives in. A missing directory has no route metadata.
+ */
+export declare function findRouteMetaFiles(routesDirectory: string): Promise<string[]>;

package/package.json

@@ -18,7 +18,7 @@
     "modern.js",
     "tanstack-router"
   ],
-  "version": "3.9.0-ultramodern.17",
+  "version": "3.9.0-ultramodern.18",
   "engines": {
     "node": ">=20"
   },
@@ -94,19 +94,19 @@
     }
   },
   "dependencies": {
-    "@modern-js/i18n-runtime-extensions": "npm:@bleedingdev/modern-js-i18n-runtime-extensions@3.9.0-ultramodern.17",
-    "@modern-js/plugin": "npm:@bleedingdev/modern-js-plugin@3.9.0-ultramodern.17",
-    "@modern-js/runtime-extensions": "npm:@bleedingdev/modern-js-runtime-extensions@3.9.0-ultramodern.17",
-    "@modern-js/runtime-utils": "npm:@bleedingdev/modern-js-runtime-utils@3.9.0-ultramodern.17",
-    "@modern-js/types": "npm:@bleedingdev/modern-js-types@3.9.0-ultramodern.17",
-    "@modern-js/utils": "npm:@bleedingdev/modern-js-utils@3.9.0-ultramodern.17",
+    "@modern-js/i18n-runtime-extensions": "npm:@bleedingdev/modern-js-i18n-runtime-extensions@3.9.0-ultramodern.18",
+    "@modern-js/plugin": "npm:@bleedingdev/modern-js-plugin@3.9.0-ultramodern.18",
+    "@modern-js/runtime-extensions": "npm:@bleedingdev/modern-js-runtime-extensions@3.9.0-ultramodern.18",
+    "@modern-js/runtime-utils": "npm:@bleedingdev/modern-js-runtime-utils@3.9.0-ultramodern.18",
+    "@modern-js/types": "npm:@bleedingdev/modern-js-types@3.9.0-ultramodern.18",
+    "@modern-js/utils": "npm:@bleedingdev/modern-js-utils@3.9.0-ultramodern.18",
     "@swc/helpers": "^0.5.23",
     "@tanstack/react-router": "1.170.39",
     "@tanstack/router-core": "1.171.32"
   },
   "peerDependencies": {
-    "@modern-js/app-tools": "3.9.0-ultramodern.17",
-    "@modern-js/runtime": "3.9.0-ultramodern.17",
+    "@modern-js/app-tools": "3.9.0-ultramodern.18",
+    "@modern-js/runtime": "3.9.0-ultramodern.18",
     "react": "^19.2.8",
     "react-dom": "^19.2.8",
     "react-server-dom-rspack": "0.1.0"
@@ -117,9 +117,9 @@
     }
   },
   "devDependencies": {
-    "@modern-js/app-tools": "npm:@bleedingdev/modern-js-app-tools@3.9.0-ultramodern.17",
-    "@modern-js/runtime": "npm:@bleedingdev/modern-js-runtime@3.9.0-ultramodern.17",
-    "@modern-js/server-utils": "npm:@bleedingdev/modern-js-server-utils@3.9.0-ultramodern.17",
+    "@modern-js/app-tools": "npm:@bleedingdev/modern-js-app-tools@3.9.0-ultramodern.18",
+    "@modern-js/runtime": "npm:@bleedingdev/modern-js-runtime@3.9.0-ultramodern.18",
+    "@modern-js/server-utils": "npm:@bleedingdev/modern-js-server-utils@3.9.0-ultramodern.18",
     "@rslib/core": "1.0.2",
     "@scripts/rstest-config": "2.66.0",
     "@tanstack/history": "1.162.4",
@@ -153,6 +153,6 @@
   "scripts": {
     "dev": "rslib build --watch",
     "build": "rslib build",
-    "test": "rstest --passWithNoTests"
+    "test": "rstest"
   }
 }

package/rstest.config.mts

@@ -29,6 +29,7 @@ export default {
         'tests/router/loaderBridge.test.ts',
         'tests/router/localisedIdentity.test.tsx',
         'tests/router/routeHooks.test.ts',
+        'tests/router/routeMetadata.test.ts',
         'tests/router/serverPlugin.test.ts',
         'tests/router/rsc.test.tsx',
         'tests/router/slotUsageSanitizer.test.ts',

package/src/cli/artifacts.ts

@@ -5,6 +5,12 @@ import type { AppToolsContext } from '@modern-js/app-tools';
 import type { NestedRouteForCli, PageRoute } from '@modern-js/types';
 import { fs } from '@modern-js/utils';
 
+import {
+  findRouteMetaFiles,
+  ROUTE_METADATA_MANIFEST_FILE_NAME,
+  ROUTE_METADATA_MANIFEST_HEADER,
+  renderRouteMetadataManifest,
+} from './routeMetadata';
 import {
   collectCanonicalRoutesForEntry,
   generateTanstackRouterTypesSourceForEntry,
@@ -193,16 +199,52 @@ export async function writeTanstackRouterTypesForEntries(opts: {
 }
 
 /**
- * Headless regeneration of `router.gen.ts` / `register.gen.d.ts` for a generated
- * app, without running a full dev/build. Drives the app-tools analyze `onPrepare`
- * (which fires `generateEntryCode`) and returns before any bundling — the app's
- * own registered plugin-tanstack writes the artifacts via its `generateEntryCode`
- * subscriber. Reuses the exact hook dev/build use, so there is no scanning drift.
+ * Writes `src/routes/ultramodern-route-metadata.ts` from the `route.meta.ts`
+ * files below `src/routes`. Reads only the file system, never the app config.
+ */
+export async function writeRouteMetadataManifest(opts: {
+  appDirectory: string;
+}): Promise<void> {
+  const routesDirectory = path.join(opts.appDirectory, 'src', 'routes');
+  const manifestPath = path.join(
+    routesDirectory,
+    ROUTE_METADATA_MANIFEST_FILE_NAME,
+  );
+  const manifest = renderRouteMetadataManifest(
+    await findRouteMetaFiles(routesDirectory),
+  );
+  if (manifest !== null) {
+    await writeFileIfChanged(manifestPath, manifest);
+    return;
+  }
+  const previous = (await fs.pathExists(manifestPath))
+    ? await fs.readFile(manifestPath, 'utf-8')
+    : null;
+  // No valid manifest exists without routes (its namespace comes from them),
+  // and the app config imports it, so the app cannot load in this state.
+  if (previous?.startsWith(`${ROUTE_METADATA_MANIFEST_HEADER}\n`)) {
+    throw new Error(
+      `[plugin-tanstack] ${manifestPath} is generated from route.meta.ts files, but none remain below ${routesDirectory}. ` +
+        'Restore at least one route.meta.ts that exports routeMeta, or delete the manifest together with its imports.',
+    );
+  }
+}
+
+/**
+ * Headless regeneration of the route metadata manifest and of `router.gen.ts` /
+ * `register.gen.d.ts` for a generated app, without running a full dev/build.
+ * Drives the app-tools analyze `onPrepare` (which fires `generateEntryCode`)
+ * and returns before any bundling — the app's own registered plugin-tanstack
+ * writes the router artifacts via its `generateEntryCode` subscriber. Reuses
+ * the exact hook dev/build use, so there is no scanning drift.
  */
 export async function generateTanstackRouteArtifacts(opts: {
   appDirectory: string;
   version?: string;
 }): Promise<void> {
+  // The app config imports the manifest. Writing it first means a manifest
+  // that still imports a deleted route.meta.ts cannot fail the config load.
+  await writeRouteMetadataManifest(opts);
   const [{ createRunOptions }, { cli }, utils] = await Promise.all([
     import('@modern-js/app-tools/cli/run'),
     import('@modern-js/plugin/cli'),

package/src/cli/index.ts

@@ -3,7 +3,6 @@ import path from 'node:path';
 import type {
   AppNormalizedConfig,
   AppTools,
-  AppToolsContext,
   CliPlugin,
 } from '@modern-js/app-tools';
 import type { CLIPluginAPI } from '@modern-js/plugin';
@@ -15,7 +14,6 @@ import type {
 } from '@modern-js/types';
 import {
   filterRoutesForServer,
-  fs,
   NESTED_ROUTE_SPEC_FILE,
 } from '@modern-js/utils';
 import { writeTanstackRouterTypesForEntries } from './artifacts';
@@ -26,6 +24,7 @@ import {
 
 export {
   generateTanstackRouteArtifacts,
+  writeRouteMetadataManifest,
   writeTanstackRegisterFile,
   writeTanstackRouterTypesForEntries,
 } from './artifacts';

package/src/cli/routeMetadata.ts

@@ -0,0 +1,121 @@
+// @effect-diagnostics asyncFunction:off nodeBuiltinImport:off
+import { readdir } from 'node:fs/promises';
+import path from 'node:path';
+
+export const ROUTE_META_FILE_NAME = 'route.meta.ts';
+export const ROUTE_METADATA_MANIFEST_FILE_NAME =
+  'ultramodern-route-metadata.ts';
+
+export const ROUTE_METADATA_MANIFEST_HEADER = `// @generated by @modern-js/plugin-tanstack from ${ROUTE_META_FILE_NAME} files. Run routes-generate; do not edit.`;
+
+// The manifest is emitted formatted (oxfmt/Prettier style: print width 120,
+// single quotes, trailing commas) and is generated output, so formatters
+// ignore it like router.gen.ts; no formatter pass is needed to keep it stable.
+const PRINT_WIDTH = 120;
+
+const MANIFEST_BODY = `export const ultramodernLocalisedUrls = Object.fromEntries(
+  ultramodernRouteMetadata
+    .filter((route) => route.canonicalPath !== '/')
+    .map((route) => [route.canonicalPath, route.localisedPaths]),
+);
+export const ultramodernPublicRoutes = ultramodernRouteMetadata
+  .filter((route) => route.public && route.indexable)
+  .map((route) => ({
+    canonicalPath: route.canonicalPath,
+    descriptionKey: route.descriptionKey,
+    id: route.id,
+    localisedPaths: route.localisedPaths,
+    namespace: route.namespace,
+    ownerAppId: route.ownerAppId,
+    titleKey: route.titleKey,
+    ...('jsonLd' in route ? { jsonLd: route.jsonLd } : {}),
+  }));
+export const ultramodernRouteConfig = {
+  authoring: 'colocated-route-meta',
+  generatedManifest: true,
+  localisedUrls: ultramodernLocalisedUrls,
+  namespace: ultramodernRouteNamespace,
+  publicRoutes: ultramodernPublicRoutes,
+  routes: ultramodernRouteMetadata,
+  source: 'route-owned',
+} as const;
+`;
+
+const compareCodeUnits = (left: string, right: string) =>
+  left < right ? -1 : left > right ? 1 : 0;
+
+const quoteSpecifier = (specifier: string) =>
+  specifier.includes("'") ? JSON.stringify(specifier) : `'${specifier}'`;
+
+/**
+ * Renders the route metadata manifest for the `route.meta.ts` files of one
+ * routes directory. Each path is relative to that directory (either separator).
+ * Every `route.meta.ts` must export `routeMeta`; the manifest imports it
+ * statically, so the metadata is never evaluated while generating. Returns
+ * `null` when there are no route metadata files. Output depends only on the
+ * set of paths, never on their order or on the file system.
+ */
+export function renderRouteMetadataManifest(
+  routeMetaFiles: readonly string[],
+): string | null {
+  const specifiers = routeMetaFiles
+    .map(file => `./${file.replaceAll('\\', '/').replace(/\.ts$/u, '')}`)
+    .sort(compareCodeUnits);
+  if (specifiers.length === 0) {
+    return null;
+  }
+  const bindings = specifiers.map((_, index) => `route${index}`);
+  const imports = specifiers.map(
+    (specifier, index) =>
+      `import { routeMeta as ${bindings[index]} } from ${quoteSpecifier(specifier)};`,
+  );
+  const inlineRoutes = `export const ultramodernRouteMetadata = [${bindings.join(', ')}] as const;`;
+  const routes =
+    inlineRoutes.length <= PRINT_WIDTH
+      ? inlineRoutes
+      : `export const ultramodernRouteMetadata = [\n${bindings
+          .map(binding => `  ${binding},\n`)
+          .join('')}] as const;`;
+
+  return `${ROUTE_METADATA_MANIFEST_HEADER}
+${imports.join('\n')}
+
+export const ultramodernRouteNamespace = route0.namespace;
+${routes}
+${MANIFEST_BODY}`;
+}
+
+/**
+ * Lists the `route.meta.ts` files below `routesDirectory`, relative to it.
+ * Symbolic links are not followed: linked metadata belongs to the tree it
+ * lives in. A missing directory has no route metadata.
+ */
+export async function findRouteMetaFiles(
+  routesDirectory: string,
+): Promise<string[]> {
+  const files: string[] = [];
+  const visit = async (relativeDirectory: string): Promise<void> => {
+    const entries = await readdir(
+      path.join(routesDirectory, relativeDirectory),
+      { withFileTypes: true },
+    );
+    for (const entry of entries) {
+      const relativePath = path.join(relativeDirectory, entry.name);
+      if (entry.isDirectory()) {
+        await visit(relativePath);
+      } else if (entry.isFile() && entry.name === ROUTE_META_FILE_NAME) {
+        files.push(relativePath);
+      }
+    }
+  };
+  try {
+    await visit('');
+  } catch (error) {
+    const { code, path: missingPath } = error as NodeJS.ErrnoException;
+    if (code === 'ENOENT' && missingPath === routesDirectory) {
+      return [];
+    }
+    throw error;
+  }
+  return files;
+}

package/tests/router/generateRouteArtifacts.test.ts

@@ -165,6 +165,44 @@ describe('generateTanstackRouteArtifacts (headless routes-generate)', () => {
     }
   });
 
+  it('regenerates the route metadata manifest before loading the config', async () => {
+    const appDirectory = makeAppDir(true);
+    const routesDirectory = path.join(appDirectory, 'src', 'routes');
+    const manifestPath = path.join(
+      routesDirectory,
+      'ultramodern-route-metadata.ts',
+    );
+    fs.mkdirSync(path.join(routesDirectory, '[lang]'), { recursive: true });
+    fs.writeFileSync(
+      path.join(routesDirectory, '[lang]', 'route.meta.ts'),
+      "export const routeMeta = { namespace: 'app' } as const;\n",
+    );
+    // A manifest that still imports a deleted route.meta.ts makes the config
+    // (which imports the manifest) fail to load.
+    fs.writeFileSync(
+      manifestPath,
+      "import { routeMeta as route0 } from './[lang]/deleted/route.meta';\n",
+    );
+    const configLoadFailure = new Error(
+      "Cannot find module './[lang]/deleted/route.meta'",
+    );
+    cliInitMock.mockImplementationOnce(async () => {
+      throw configLoadFailure;
+    });
+    try {
+      await expect(
+        generateTanstackRouteArtifacts({ appDirectory }),
+      ).rejects.toBe(configLoadFailure);
+      const manifest = fs.readFileSync(manifestPath, 'utf8');
+      expect(manifest).toContain(
+        "import { routeMeta as route0 } from './[lang]/route.meta';",
+      );
+      expect(manifest).not.toContain('deleted');
+    } finally {
+      fs.rmSync(appDirectory, { force: true, recursive: true });
+    }
+  });
+
   it('throws a clear error when no config file exists', async () => {
     const appDirectory = makeAppDir(false);
 

package/tests/router/prefetchLinkPreload.test.tsx

@@ -1,5 +1,4 @@
 import { render } from '@testing-library/react';
-import React from 'react';
 import { Link } from '../../src/runtime/prefetchLink';
 
 type CapturedOptions = {

package/tests/router/routeMetadata.test.ts

@@ -0,0 +1,171 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { writeRouteMetadataManifest } from '../../src/cli/artifacts';
+import { renderRouteMetadataManifest } from '../../src/cli/routeMetadata';
+
+const routeMeta = (id: string) =>
+  `export const routeMeta = { id: '${id}', namespace: 'shop' } as const;\n`;
+
+const EXPECTED_MANIFEST = `// @generated by @modern-js/plugin-tanstack from route.meta.ts files. Run routes-generate; do not edit.
+import { routeMeta as route0 } from './[lang]/about/route.meta';
+import { routeMeta as route1 } from './[lang]/route.meta';
+import { routeMeta as route2 } from './[lang]/stores/[id]/route.meta';
+
+export const ultramodernRouteNamespace = route0.namespace;
+export const ultramodernRouteMetadata = [route0, route1, route2] as const;
+export const ultramodernLocalisedUrls = Object.fromEntries(
+  ultramodernRouteMetadata
+    .filter((route) => route.canonicalPath !== '/')
+    .map((route) => [route.canonicalPath, route.localisedPaths]),
+);
+export const ultramodernPublicRoutes = ultramodernRouteMetadata
+  .filter((route) => route.public && route.indexable)
+  .map((route) => ({
+    canonicalPath: route.canonicalPath,
+    descriptionKey: route.descriptionKey,
+    id: route.id,
+    localisedPaths: route.localisedPaths,
+    namespace: route.namespace,
+    ownerAppId: route.ownerAppId,
+    titleKey: route.titleKey,
+    ...('jsonLd' in route ? { jsonLd: route.jsonLd } : {}),
+  }));
+export const ultramodernRouteConfig = {
+  authoring: 'colocated-route-meta',
+  generatedManifest: true,
+  localisedUrls: ultramodernLocalisedUrls,
+  namespace: ultramodernRouteNamespace,
+  publicRoutes: ultramodernPublicRoutes,
+  routes: ultramodernRouteMetadata,
+  source: 'route-owned',
+} as const;
+`;
+
+describe('route metadata manifest', () => {
+  let appDirectory: string;
+  let routesDirectory: string;
+  const write = (relativePath: string, content: string) => {
+    const file = path.join(routesDirectory, relativePath);
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.writeFileSync(file, content);
+  };
+
+  beforeEach(() => {
+    appDirectory = fs.mkdtempSync(path.join(os.tmpdir(), 'route-metadata-'));
+    routesDirectory = path.join(appDirectory, 'src', 'routes');
+  });
+
+  afterEach(() => {
+    fs.rmSync(appDirectory, { recursive: true, force: true });
+  });
+
+  it('writes a byte-stable, formatted manifest from route.meta.ts files', async () => {
+    write('[lang]/stores/[id]/route.meta.ts', routeMeta('store'));
+    write('[lang]/route.meta.ts', routeMeta('home'));
+    write('[lang]/about/route.meta.ts', routeMeta('about'));
+    write('[lang]/about/page.tsx', 'export default () => null;\n');
+    // Linked metadata belongs to another tree; following it would make the
+    // manifest depend on where the link points.
+    fs.mkdirSync(path.join(routesDirectory, '[lang]/linked-file'));
+    fs.symlinkSync(
+      path.join(routesDirectory, '[lang]/route.meta.ts'),
+      path.join(routesDirectory, '[lang]/linked-file/route.meta.ts'),
+    );
+    fs.symlinkSync(
+      path.join(routesDirectory, '[lang]/about'),
+      path.join(routesDirectory, '[lang]/linked'),
+    );
+    const manifestPath = path.join(
+      routesDirectory,
+      'ultramodern-route-metadata.ts',
+    );
+
+    await writeRouteMetadataManifest({ appDirectory });
+    expect(fs.readFileSync(manifestPath, 'utf8')).toBe(EXPECTED_MANIFEST);
+
+    const writtenAt = fs.statSync(manifestPath).mtimeMs;
+    await new Promise(resolve => setTimeout(resolve, 20));
+    await writeRouteMetadataManifest({ appDirectory });
+    expect(fs.readFileSync(manifestPath, 'utf8')).toBe(EXPECTED_MANIFEST);
+    expect(fs.statSync(manifestPath).mtimeMs).toBe(writtenAt);
+  });
+
+  it('drops deleted route metadata from an existing manifest', async () => {
+    write('[lang]/route.meta.ts', routeMeta('home'));
+    write('[lang]/gone/route.meta.ts', routeMeta('gone'));
+    await writeRouteMetadataManifest({ appDirectory });
+    fs.rmSync(path.join(routesDirectory, '[lang]/gone'), { recursive: true });
+
+    await writeRouteMetadataManifest({ appDirectory });
+
+    const manifest = fs.readFileSync(
+      path.join(routesDirectory, 'ultramodern-route-metadata.ts'),
+      'utf8',
+    );
+    expect(manifest).not.toContain('gone');
+    expect(manifest).toContain(
+      "import { routeMeta as route0 } from './[lang]/route.meta';\n\n",
+    );
+  });
+
+  it('names the fix once the last route metadata is deleted', async () => {
+    write('[lang]/route.meta.ts', routeMeta('home'));
+    await writeRouteMetadataManifest({ appDirectory });
+    const manifestPath = path.join(
+      routesDirectory,
+      'ultramodern-route-metadata.ts',
+    );
+    const manifest = fs.readFileSync(manifestPath, 'utf8');
+    fs.rmSync(path.join(routesDirectory, '[lang]/route.meta.ts'));
+
+    await expect(writeRouteMetadataManifest({ appDirectory })).rejects.toThrow(
+      /none remain below .*Restore at least one route\.meta\.ts/u,
+    );
+    expect(fs.readFileSync(manifestPath, 'utf8')).toBe(manifest);
+  });
+
+  it('keeps an authored file at the manifest path', async () => {
+    write('ultramodern-route-metadata.ts', 'export const authored = true;\n');
+
+    await writeRouteMetadataManifest({ appDirectory });
+
+    expect(
+      fs.readFileSync(
+        path.join(routesDirectory, 'ultramodern-route-metadata.ts'),
+        'utf8',
+      ),
+    ).toBe('export const authored = true;\n');
+  });
+
+  it('writes nothing for an app without route metadata', async () => {
+    await writeRouteMetadataManifest({ appDirectory });
+    write('[lang]/page.tsx', 'export default () => null;\n');
+    await writeRouteMetadataManifest({ appDirectory });
+
+    expect(fs.readdirSync(routesDirectory)).toEqual(['[lang]']);
+  });
+
+  it('renders independently of input order and separators', () => {
+    expect(
+      renderRouteMetadataManifest([
+        '[lang]\\stores\\[id]\\route.meta.ts',
+        '[lang]/route.meta.ts',
+        '[lang]/about/route.meta.ts',
+      ]),
+    ).toBe(EXPECTED_MANIFEST);
+  });
+
+  it('breaks the route list one binding per line past the print width', () => {
+    const manifest = renderRouteMetadataManifest(
+      Array.from({ length: 12 }, (_, index) => `r${index}/route.meta.ts`),
+    );
+
+    expect(manifest).toContain(
+      `export const ultramodernRouteMetadata = [\n${Array.from(
+        { length: 12 },
+        (_, index) => `  route${index},\n`,
+      ).join('')}] as const;\n`,
+    );
+  });
+});