@bleedingdev/modern-js-create 3.2.0-ultramodern.120 → 3.2.0-ultramodern.122

package/dist/esm/ultramodern-workspace/public-surface.js

@@ -0,0 +1,183 @@
+import node_fs from "node:fs";
+import node_path from "node:path";
+import { createRouteHeadModule } from "./app-files.js";
+import { relativeRootFor } from "./naming.js";
+import { createPublicHeadRobotsPolicy, createPublicSurfaceContentExpansionPolicy } from "./policy.js";
+import { createJsonLdHelperModule, createPublicRouteMetadata, createRouteAliasPage, createRouteMetaFilePath, createRouteMetaModule, createRouteMetadataModule, createRouteOwnedI18nPaths, createRoutePageFilePath, isConcretePublicPath, normalisePublicPath } from "./routes.js";
+import { supportedWorkspaceLanguages } from "./types.js";
+const publicSurfaceManagedSourceAssetPaths = [
+    'config/public/robots.txt',
+    'config/public/sitemap.xml',
+    'config/public/site.webmanifest'
+];
+const publicSurfaceBaseOutputFiles = [
+    'robots.txt'
+];
+const publicSurfacePublicRouteOutputFiles = [
+    'sitemap.xml',
+    'site.webmanifest'
+];
+function createLocalisedPublicPath(pathname, language) {
+    const publicPath = normalisePublicPath(pathname);
+    return '/' === publicPath ? `/${language}` : `/${language}${publicPath}`;
+}
+function uniqueSorted(values) {
+    return Array.from(new Set(values)).sort((left, right)=>left.localeCompare(right));
+}
+function createPublicSurfaceRouteEntries(app) {
+    return createPublicRouteMetadata(app).map((route)=>{
+        const localeUrlPaths = Object.fromEntries(supportedWorkspaceLanguages.map((language)=>[
+                language,
+                createLocalisedPublicPath(route.localisedPaths[language], language)
+            ]));
+        if (!Object.values(localeUrlPaths).every(isConcretePublicPath)) return;
+        return {
+            ...route,
+            canonicalUrlPath: localeUrlPaths.en,
+            localeUrlPaths
+        };
+    }).filter((route)=>void 0 !== route).sort((left, right)=>left.canonicalUrlPath.localeCompare(right.canonicalUrlPath) || left.id.localeCompare(right.id));
+}
+function createPublicSurfaceUrlPaths(app) {
+    return uniqueSorted(createPublicSurfaceRouteEntries(app).flatMap((route)=>supportedWorkspaceLanguages.map((language)=>route.localeUrlPaths[language])));
+}
+function createPublicSurfaceOutputFiles(app) {
+    return [
+        ...publicSurfaceBaseOutputFiles,
+        ...createPublicRouteMetadata(app).length > 0 ? publicSurfacePublicRouteOutputFiles : []
+    ];
+}
+function createPublicSurfaceGenerationCommand(app, target, requirePublicOrigin = false) {
+    return `node ${relativeRootFor(app.directory)}/scripts/generate-public-surface-assets.mjs --app ${app.id} --target ${target}${requirePublicOrigin ? ' --require-public-origin' : ''}`;
+}
+function rewriteWorkspaceAssetsForApp(workspaceRoot, app) {
+    for (const relativePath of publicSurfaceManagedSourceAssetPaths)node_fs.rmSync(node_path.join(workspaceRoot, app.directory, relativePath), {
+        force: true
+    });
+}
+function createPublicSurfaceContract(app) {
+    const files = createPublicSurfaceOutputFiles(app);
+    const contentExpansionPolicy = createPublicSurfaceContentExpansionPolicy();
+    return {
+        authoring: 'colocated-route-meta',
+        artifactLifecycle: 'build-and-deploy-output',
+        generatedManifest: './src/routes/ultramodern-route-metadata',
+        source: 'route-owned-public-routes',
+        metadataExport: './src/routes/ultramodern-route-metadata',
+        generator: "scripts/generate-public-surface-assets.mjs",
+        outputRoot: 'dist/public',
+        cloudflareOutputRoot: '.output/public',
+        privateRoutePolicy: 'omit-from-generated-public-surface',
+        files,
+        omittedByDefault: [
+            'api-catalog.json',
+            'llms.txt',
+            'security.txt'
+        ],
+        languages: [
+            ...supportedWorkspaceLanguages
+        ],
+        contentExpansion: {
+            authoring: 'route-owned-esm-provider',
+            defaultProviderFile: contentExpansionPolicy.defaultProviderFile,
+            entryExport: 'default-or-entries',
+            paramsSource: 'params-or-localeParams',
+            draftPolicy: contentExpansionPolicy.draftPolicy,
+            indexablePolicy: contentExpansionPolicy.indexablePolicy,
+            lifecycle: 'executed-during-public-surface-generation'
+        },
+        contentSources: [],
+        publicRoutes: createPublicRouteMetadata(app),
+        routeEntries: createPublicSurfaceRouteEntries(app),
+        concreteUrlPaths: createPublicSurfaceUrlPaths(app)
+    };
+}
+function createPublicHeadContract() {
+    const robotsPolicy = createPublicHeadRobotsPolicy();
+    return {
+        authoring: 'colocated-route-meta',
+        generator: './src/routes/ultramodern-route-head',
+        renderer: '@modern-js/runtime/head Helmet',
+        ssr: true,
+        title: {
+            required: true,
+            source: 'route.titleKey'
+        },
+        description: {
+            required: true,
+            source: "route.descriptionKey"
+        },
+        canonical: {
+            publicIndexableOnly: true,
+            source: 'localized canonical route URL'
+        },
+        alternates: {
+            hreflang: [
+                ...supportedWorkspaceLanguages
+            ],
+            xDefault: 'en'
+        },
+        openGraph: {
+            publicIndexableOnly: true,
+            required: [
+                'og:title',
+                "og:description",
+                'og:url',
+                'og:type'
+            ]
+        },
+        twitter: {
+            publicIndexableOnly: true,
+            required: [
+                'twitter:card',
+                'twitter:title',
+                "twitter:description"
+            ]
+        },
+        structuredData: {
+            publicIndexableOnly: true,
+            optional: true,
+            source: 'route.jsonLd',
+            inference: false,
+            helperModule: './src/routes/ultramodern-jsonld',
+            helperTypes: [
+                'WebPage',
+                'WebApplication',
+                'SoftwareApplication',
+                'BreadcrumbList',
+                'FAQPage',
+                'Organization'
+            ],
+            sanitizesHtmlOpenBracket: true
+        },
+        privateRouteRobots: robotsPolicy.privateRouteRobots
+    };
+}
+function createPublicWebAppArtifacts(app) {
+    const routeMetadata = createRouteOwnedI18nPaths(app);
+    return {
+        jsonLdHelperFile: {
+            path: `${app.directory}/src/routes/ultramodern-jsonld.ts`,
+            content: createJsonLdHelperModule()
+        },
+        routeMetadataFile: {
+            path: `${app.directory}/src/routes/ultramodern-route-metadata.ts`,
+            content: createRouteMetadataModule(app)
+        },
+        routeHeadFile: {
+            path: `${app.directory}/src/routes/ultramodern-route-head.tsx`,
+            content: createRouteHeadModule(app)
+        },
+        routeMetaFiles: routeMetadata.map((route)=>({
+                path: createRouteMetaFilePath(app, route.canonicalPath),
+                content: createRouteMetaModule(route)
+            })),
+        routeAliasFiles: routeMetadata.filter((route)=>'/' !== route.canonicalPath && 'shell' !== app.kind).map((route)=>({
+                path: createRoutePageFilePath(app, route.canonicalPath),
+                content: createRouteAliasPage(route.canonicalPath)
+            })),
+        publicHead: createPublicHeadContract(),
+        publicSurface: createPublicSurfaceContract(app)
+    };
+}
+export { createLocalisedPublicPath, createPublicHeadContract, createPublicSurfaceContract, createPublicSurfaceGenerationCommand, createPublicSurfaceOutputFiles, createPublicSurfaceRouteEntries, createPublicSurfaceUrlPaths, createPublicWebAppArtifacts, publicSurfaceBaseOutputFiles, publicSurfaceManagedSourceAssetPaths, publicSurfacePublicRouteOutputFiles, rewriteWorkspaceAssetsForApp, uniqueSorted };

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

@@ -0,0 +1,280 @@
+import { appI18nNamespace } from "./descriptors.js";
+import { sortJsonValue } from "./types.js";
+const privateAppRoutePublicness = {
+    indexable: false,
+    public: false,
+    publicSurface: 'private-app-screen'
+};
+function createRouteOwnedI18nPaths(app) {
+    const namespace = appI18nNamespace(app);
+    const base = {
+        descriptionKey: `${namespace}.seo.description`,
+        mfBoundaryId: app.mfName,
+        namespace,
+        ownerAppId: app.id,
+        ...privateAppRoutePublicness
+    };
+    if ('shell' === app.kind) return [
+        {
+            ...base,
+            canonicalPath: '/',
+            id: 'shell-home',
+            localisedPaths: {
+                cs: '/',
+                en: '/'
+            },
+            titleKey: 'shell.title'
+        }
+    ];
+    return [
+        {
+            ...base,
+            canonicalPath: '/',
+            id: `${app.id}-home`,
+            localisedPaths: {
+                cs: '/',
+                en: '/'
+            },
+            titleKey: `${namespace}.title`
+        }
+    ];
+}
+function isPublicIndexableRoute(route) {
+    return route.public && route.indexable;
+}
+function createLocalisedUrlsMapFromRoutes(routes) {
+    return Object.fromEntries(routes.flatMap((route)=>{
+        if ('/' === route.canonicalPath) return [];
+        return Array.from(new Set([
+            route.canonicalPath,
+            ...Object.values(route.localisedPaths)
+        ])).map((pathname)=>[
+                pathname,
+                route.localisedPaths
+            ]);
+    }));
+}
+function createLocalisedUrlsMap(app) {
+    return createLocalisedUrlsMapFromRoutes(createRouteOwnedI18nPaths(app));
+}
+function createPublicRouteMetadataFromRoutes(routes) {
+    return routes.filter(isPublicIndexableRoute).map((route)=>{
+        const metadata = {
+            canonicalPath: route.canonicalPath,
+            id: route.id,
+            localisedPaths: route.localisedPaths,
+            namespace: route.namespace,
+            ownerAppId: route.ownerAppId,
+            descriptionKey: route.descriptionKey,
+            titleKey: route.titleKey
+        };
+        if (void 0 !== route.jsonLd) metadata.jsonLd = route.jsonLd;
+        return metadata;
+    });
+}
+function createPublicRouteMetadata(app) {
+    return createPublicRouteMetadataFromRoutes(createRouteOwnedI18nPaths(app));
+}
+function createJsonLdHelperModule() {
+    return `export type JsonLdPrimitive = string | number | boolean | null;
+export type JsonLdValue =
+  | JsonLdPrimitive
+  | readonly JsonLdValue[]
+  | { readonly [key: string]: JsonLdValue };
+export type JsonLdObject = Readonly<Record<string, JsonLdValue>>;
+export type RouteJsonLd = JsonLdObject | readonly JsonLdObject[];
+
+const schemaContext = 'https://schema.org' as const;
+
+type SchemaObject<TType extends string> = JsonLdObject & {
+  readonly '@context': typeof schemaContext;
+  readonly '@type': TType;
+};
+
+type ThingReference =
+  | string
+  | {
+      readonly '@id'?: string;
+      readonly '@type'?: string;
+      readonly name?: string;
+      readonly url?: string;
+    };
+
+const withSchemaContext = <TType extends string, TInput extends object>(
+  type: TType,
+  input: TInput,
+): SchemaObject<TType> & TInput => ({
+  '@context': schemaContext,
+  '@type': type,
+  ...input,
+});
+
+export const defineRouteJsonLd = <TJsonLd extends RouteJsonLd>(
+  jsonLd: TJsonLd,
+): TJsonLd => jsonLd;
+
+export interface WebPageJsonLdInput {
+  readonly name: string;
+  readonly url: string;
+  readonly description?: string;
+  readonly inLanguage?: string | readonly string[];
+  readonly isPartOf?: ThingReference;
+}
+
+export const webPageJsonLd = (input: WebPageJsonLdInput) =>
+  withSchemaContext('WebPage', input);
+
+export interface WebApplicationJsonLdInput {
+  readonly name: string;
+  readonly url: string;
+  readonly applicationCategory?: string;
+  readonly browserRequirements?: string;
+  readonly description?: string;
+  readonly operatingSystem?: string;
+}
+
+export const webApplicationJsonLd = (input: WebApplicationJsonLdInput) =>
+  withSchemaContext('WebApplication', input);
+
+export interface SoftwareApplicationJsonLdInput {
+  readonly name: string;
+  readonly url: string;
+  readonly applicationCategory?: string;
+  readonly applicationSubCategory?: string;
+  readonly description?: string;
+  readonly offers?: ThingReference;
+  readonly operatingSystem?: string;
+}
+
+export const softwareApplicationJsonLd = (
+  input: SoftwareApplicationJsonLdInput,
+) => withSchemaContext('SoftwareApplication', input);
+
+export interface OrganizationJsonLdInput {
+  readonly name: string;
+  readonly url?: string;
+  readonly logo?: string;
+  readonly sameAs?: readonly string[];
+}
+
+export const organizationJsonLd = (input: OrganizationJsonLdInput) =>
+  withSchemaContext('Organization', input);
+
+export interface BreadcrumbListItemInput {
+  readonly name: string;
+  readonly item: string;
+}
+
+export const breadcrumbListJsonLd = (
+  items: readonly BreadcrumbListItemInput[],
+) =>
+  withSchemaContext('BreadcrumbList', {
+    itemListElement: items.map((entry, index) => ({
+      '@type': 'ListItem',
+      item: entry.item,
+      name: entry.name,
+      position: index + 1,
+    })),
+  });
+
+export interface FAQPageQuestionInput {
+  readonly name: string;
+  readonly acceptedAnswer: {
+    readonly text: string;
+  };
+}
+
+export const faqPageJsonLd = (questions: readonly FAQPageQuestionInput[]) =>
+  withSchemaContext('FAQPage', {
+    mainEntity: questions.map(question => ({
+      '@type': 'Question',
+      acceptedAnswer: {
+        '@type': 'Answer',
+        text: question.acceptedAnswer.text,
+      },
+      name: question.name,
+    })),
+  });
+`;
+}
+function createRouteMetadataModule(app) {
+    const routes = sortJsonValue(createRouteOwnedI18nPaths(app));
+    const localisedUrls = sortJsonValue(createLocalisedUrlsMap(app));
+    const publicRoutes = sortJsonValue(createPublicRouteMetadata(app));
+    const namespace = appI18nNamespace(app);
+    return `// @generated by @modern-js/create.
+// Author route metadata in colocated src/routes/**/route.meta.ts files.
+// This compatibility manifest is regenerated from route-owned metadata.
+
+export const ultramodernRouteNamespace = '${namespace}' as const;
+
+export const ultramodernRouteMetadata = ${JSON.stringify(routes, null, 2)} as const;
+
+export const ultramodernLocalisedUrls = ${JSON.stringify(localisedUrls, null, 2)} as const;
+
+export const ultramodernPublicRoutes = ${JSON.stringify(publicRoutes, null, 2)} as const;
+
+export const ultramodernRouteConfig = {
+  authoring: 'colocated-route-meta',
+  generatedManifest: true,
+  localisedUrls: ultramodernLocalisedUrls,
+  namespace: ultramodernRouteNamespace,
+  publicRoutes: ultramodernPublicRoutes,
+  routes: ultramodernRouteMetadata,
+  source: 'route-owned',
+} as const;
+`;
+}
+function createRouteMetaModule(route) {
+    return `const routeMeta = ${JSON.stringify(sortJsonValue(route), null, 2)} as const;
+
+export default routeMeta;
+export { routeMeta };
+`;
+}
+function normalisePublicPath(pathname) {
+    const normalised = pathname.trim().replaceAll(/\/+/gu, '/').replace(/\/+$/u, '');
+    return normalised.length > 0 && normalised.startsWith('/') ? normalised : `/${normalised}`;
+}
+function splitPublicPathSegments(pathname) {
+    return normalisePublicPath(pathname).split('/').filter(Boolean);
+}
+function routePathParamName(segment) {
+    if (segment.startsWith(':')) return segment.slice(1).replace(/[?*+]$/u, '');
+    if (segment.startsWith('[') && segment.endsWith(']')) return segment.slice(1, -1).replace(/^\.\.\./u, '').replace(/\$$/u, '');
+}
+function isDynamicPublicPathSegment(segment) {
+    return void 0 !== routePathParamName(segment) || segment.includes('*') || segment.startsWith('[');
+}
+function isConcretePublicPath(pathname) {
+    return !splitPublicPathSegments(pathname).some(isDynamicPublicPathSegment);
+}
+function routeSegmentToDirectory(segment) {
+    const paramName = routePathParamName(segment);
+    if (paramName && segment.startsWith(':')) return segment.endsWith('?') ? `[${paramName}$]` : `[${paramName}]`;
+    return segment;
+}
+function routePathDirectorySegments(routePath) {
+    return splitPublicPathSegments(routePath).map(routeSegmentToDirectory);
+}
+function createRoutePageFilePath(app, canonicalPath) {
+    const segments = routePathDirectorySegments(canonicalPath);
+    return `${app.directory}/src/routes/[lang]/${[
+        ...segments,
+        'page.tsx'
+    ].join('/')}`;
+}
+function createRouteMetaFilePath(app, canonicalPath) {
+    const segments = routePathDirectorySegments(canonicalPath);
+    return `${app.directory}/src/routes/[lang]/${[
+        ...segments,
+        'route.meta.ts'
+    ].join('/')}`;
+}
+function createRouteAliasPage(canonicalPath) {
+    const depth = canonicalPath.split('/').filter(Boolean).length;
+    const rootPageImport = `${'../'.repeat(depth)}page`;
+    return `export { default } from '${rootPageImport}';
+`;
+}
+export { createJsonLdHelperModule, createLocalisedUrlsMap, createLocalisedUrlsMapFromRoutes, createPublicRouteMetadata, createPublicRouteMetadataFromRoutes, createRouteAliasPage, createRouteMetaFilePath, createRouteMetaModule, createRouteMetadataModule, createRouteOwnedI18nPaths, createRoutePageFilePath, isConcretePublicPath, isDynamicPublicPathSegment, isPublicIndexableRoute, normalisePublicPath, privateAppRoutePublicness, routePathDirectorySegments, routePathParamName, routeSegmentToDirectory, splitPublicPathSegments };

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

@@ -0,0 +1,16 @@
+function sortJsonValue(value) {
+    if (Array.isArray(value)) return value.map(sortJsonValue);
+    if (null !== value && 'object' == typeof value) return Object.fromEntries(Object.entries(value).sort(([left], [right])=>left.localeCompare(right)).map(([key, entry])=>[
+            key,
+            sortJsonValue(entry)
+        ]));
+    return value;
+}
+const supportedWorkspaceLanguages = [
+    'en',
+    'cs'
+];
+function isRecord(value) {
+    return null !== value && 'object' == typeof value && !Array.isArray(value);
+}
+export { isRecord, sortJsonValue, supportedWorkspaceLanguages };

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

@@ -0,0 +1,34 @@
+const TANSTACK_ROUTER_VERSION = '1.170.15';
+const MODULE_FEDERATION_VERSION = '2.5.1';
+const ZEPHYR_RSPACK_PLUGIN_VERSION = '1.1.1';
+const ZEPHYR_AGENT_VERSION = '1.1.1';
+const WRANGLER_VERSION = '4.99.0';
+const CLOUDFLARE_COMPATIBILITY_DATE = '2026-06-02';
+const TAILWIND_VERSION = '4.3.0';
+const TAILWIND_POSTCSS_VERSION = '4.3.0';
+const POSTCSS_VERSION = '8.5.15';
+const EFFECT_TSGO_VERSION = '0.14.3';
+const TYPESCRIPT_VERSION = '6.0.3';
+const TYPESCRIPT_NATIVE_PREVIEW_VERSION = '7.0.0-dev.20260610.1';
+const OXLINT_VERSION = '1.69.0';
+const OXFMT_VERSION = '0.54.0';
+const ULTRACITE_VERSION = '7.8.3';
+const LEFTHOOK_VERSION = '^2.1.9';
+const I18NEXT_VERSION = '26.3.1';
+const NODE_FETCH_VERSION = '^3.3.2';
+const REACT_VERSION = '^19.2.7';
+const REACT_DOM_VERSION = '^19.2.7';
+const REACT_ROUTER_DOM_VERSION = '7.17.0';
+const TYPES_REACT_VERSION = '^19.2.17';
+const TYPES_REACT_DOM_VERSION = '^19.2.3';
+const NODE_VERSION = '26.3.0';
+const PNPM_VERSION = '11.5.3';
+const RSTACK_AGENT_SKILLS_COMMIT = '61c948b42512e223bad44b83af4080eba48b2677';
+const MODULE_FEDERATION_AGENT_SKILLS_COMMIT = '07bb5b6c43ad457609e00c081b72d4c42508ec76';
+const ultramodernWorkspaceVersions = {
+    tanstackRouter: TANSTACK_ROUTER_VERSION,
+    moduleFederation: MODULE_FEDERATION_VERSION,
+    tailwind: TAILWIND_VERSION,
+    tailwindPostcss: TAILWIND_POSTCSS_VERSION
+};
+export { CLOUDFLARE_COMPATIBILITY_DATE, EFFECT_TSGO_VERSION, I18NEXT_VERSION, LEFTHOOK_VERSION, MODULE_FEDERATION_AGENT_SKILLS_COMMIT, MODULE_FEDERATION_VERSION, NODE_FETCH_VERSION, NODE_VERSION, OXFMT_VERSION, OXLINT_VERSION, PNPM_VERSION, POSTCSS_VERSION, REACT_DOM_VERSION, REACT_ROUTER_DOM_VERSION, REACT_VERSION, RSTACK_AGENT_SKILLS_COMMIT, TAILWIND_POSTCSS_VERSION, TAILWIND_VERSION, TANSTACK_ROUTER_VERSION, TYPESCRIPT_NATIVE_PREVIEW_VERSION, TYPESCRIPT_VERSION, TYPES_REACT_DOM_VERSION, TYPES_REACT_VERSION, ULTRACITE_VERSION, WRANGLER_VERSION, ZEPHYR_AGENT_VERSION, ZEPHYR_RSPACK_PLUGIN_VERSION, ultramodernWorkspaceVersions };

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

@@ -0,0 +1,91 @@
+import { remoteComponentOutputPath } from "./demo-components.js";
+import { appHasEffectApi, appI18nNamespace, remoteDependencyAlias, shellApp } from "./descriptors.js";
+import { verticalEffectGroupName } from "./effect-api.js";
+import { readFileTemplate, renderFileTemplate, writeFileReplacing } from "./fs-io.js";
+import { packageName, tailwindPrefixForApp } from "./naming.js";
+import { createCloudflareSecurityContract } from "./policy.js";
+import { publicSurfaceManagedSourceAssetPaths } from "./public-surface.js";
+import { createLocalisedUrlsMap, createRouteMetaFilePath, createRouteOwnedI18nPaths, createRoutePageFilePath } from "./routes.js";
+import { CLOUDFLARE_COMPATIBILITY_DATE, NODE_VERSION, PNPM_VERSION } from "./versions.js";
+function createAssertMfTypesScript(remotes = []) {
+    return renderFileTemplate("workspace-scripts/assert-mf-types.mjs", {
+        defaultAppDirsJson: JSON.stringify(remotes.map((remote)=>remote.directory), null, 2)
+    });
+}
+function createWorkspaceValidationScript(scope, enableTailwind, remotes = []) {
+    const verticals = remotes.filter(appHasEffectApi).map((remote)=>({
+            id: remote.id,
+            domain: remote.domain,
+            stem: remote.effectApi.stem,
+            group: verticalEffectGroupName(remote),
+            path: remote.directory,
+            mfName: remote.mfName,
+            apiPrefix: remote.effectApi.prefix,
+            tailwindPrefix: tailwindPrefixForApp(remote),
+            zephyrAlias: remoteDependencyAlias(remote),
+            packageName: packageName(scope, remote.packageSuffix),
+            exposes: Object.keys(remote.exposes ?? {}),
+            componentPaths: Object.keys(remote.exposes ?? {}).map((expose)=>remoteComponentOutputPath(remote, expose)).filter((componentPath)=>Boolean(componentPath)),
+            namespace: appI18nNamespace(remote),
+            routePagePaths: createRouteOwnedI18nPaths(remote).filter((route)=>'/' !== route.canonicalPath).map((route)=>createRoutePageFilePath(remote, route.canonicalPath)),
+            routeMetaPaths: createRouteOwnedI18nPaths(remote).map((route)=>createRouteMetaFilePath(remote, route.canonicalPath)),
+            localisedUrls: createLocalisedUrlsMap(remote),
+            verticalRefs: remote.verticalRefs ?? []
+        }));
+    const shellRouteMetaPaths = createRouteOwnedI18nPaths(shellApp).map((route)=>createRouteMetaFilePath(shellApp, route.canonicalPath));
+    const shellNamespace = appI18nNamespace(shellApp);
+    const oldRemotePaths = [
+        'apps/remotes'
+    ];
+    const expectedBuildScript = remotes.length > 0 ? 'ULTRAMODERN_ZEPHYR=false pnpm -r --filter "./verticals/*" run build && ULTRAMODERN_ZEPHYR=false pnpm --filter "./apps/shell-super-app" run build && pnpm mf:types && pnpm performance:readiness' : 'ULTRAMODERN_ZEPHYR=false pnpm --filter "./apps/shell-super-app" run build && pnpm mf:types && pnpm performance:readiness';
+    const expectedCloudflareBuildScript = remotes.length > 0 ? 'pnpm -r --filter "./verticals/*" run cloudflare:build && pnpm --filter "./apps/shell-super-app" run cloudflare:build && pnpm mf:types' : 'pnpm --filter "./apps/shell-super-app" run cloudflare:build && pnpm mf:types';
+    const expectedCloudflareDeployScript = remotes.length > 0 ? 'pnpm -r --filter "./verticals/*" run cloudflare:deploy && pnpm --filter "./apps/shell-super-app" run cloudflare:deploy' : 'pnpm --filter "./apps/shell-super-app" run cloudflare:deploy';
+    const expectedCloudflareSecurity = createCloudflareSecurityContract();
+    return renderFileTemplate("workspace-scripts/validate-ultramodern-workspace.mjs", {
+        packageScope: scope,
+        nodeVersion: NODE_VERSION,
+        pnpmVersion: PNPM_VERSION,
+        tailwindEnabledJson: JSON.stringify(enableTailwind),
+        fullStackVerticalsJson: JSON.stringify(verticals, null, 2),
+        shellNamespaceJson: JSON.stringify(shellNamespace),
+        oldRemotePathsJson: JSON.stringify(oldRemotePaths, null, 2),
+        expectedBuildScriptJson: JSON.stringify(expectedBuildScript),
+        expectedCloudflareBuildScriptJson: JSON.stringify(expectedCloudflareBuildScript),
+        expectedCloudflareDeployScriptJson: JSON.stringify(expectedCloudflareDeployScript),
+        expectedCloudflareSecurityJson: JSON.stringify(expectedCloudflareSecurity, null, 2),
+        publicSurfaceManagedSourceAssetPathsJson: JSON.stringify([
+            ...publicSurfaceManagedSourceAssetPaths
+        ], null, 2),
+        shellRouteMetaPathsJson: JSON.stringify(shellRouteMetaPaths, null, 2),
+        cloudflareCompatibilityDate: CLOUDFLARE_COMPATIBILITY_DATE
+    });
+}
+function createWorkspaceI18nBoundaryValidationScript() {
+    return readFileTemplate("workspace-scripts/check-ultramodern-i18n-boundaries.mjs");
+}
+function createPublicSurfaceAssetsScript() {
+    return readFileTemplate("workspace-scripts/generate-public-surface-assets.mjs");
+}
+function createCloudflareProofHelperScript() {
+    return readFileTemplate("workspace-scripts/ultramodern-cloudflare-proof.mjs");
+}
+function createCloudflareVersionProofScript() {
+    return readFileTemplate("workspace-scripts/proof-cloudflare-version.mjs");
+}
+function createPerformanceReadinessConfigScript() {
+    return readFileTemplate("workspace-scripts/ultramodern-performance-readiness.config.mjs");
+}
+function createPerformanceReadinessScript() {
+    return readFileTemplate("workspace-scripts/ultramodern-performance-readiness.mjs");
+}
+function writeGeneratedWorkspaceScripts(targetDir, scope, enableTailwind, remotes = []) {
+    writeFileReplacing(targetDir, "scripts/assert-mf-types.mjs", createAssertMfTypesScript(remotes));
+    writeFileReplacing(targetDir, "scripts/validate-ultramodern-workspace.mjs", createWorkspaceValidationScript(scope, enableTailwind, remotes));
+    writeFileReplacing(targetDir, "scripts/check-ultramodern-i18n-boundaries.mjs", createWorkspaceI18nBoundaryValidationScript());
+    writeFileReplacing(targetDir, "scripts/generate-public-surface-assets.mjs", createPublicSurfaceAssetsScript());
+    writeFileReplacing(targetDir, "scripts/ultramodern-cloudflare-proof.mjs", createCloudflareProofHelperScript());
+    writeFileReplacing(targetDir, "scripts/proof-cloudflare-version.mjs", createCloudflareVersionProofScript());
+    writeFileReplacing(targetDir, "scripts/ultramodern-performance-readiness.config.mjs", createPerformanceReadinessConfigScript());
+    writeFileReplacing(targetDir, "scripts/ultramodern-performance-readiness.mjs", createPerformanceReadinessScript());
+}
+export { createAssertMfTypesScript, createCloudflareProofHelperScript, createCloudflareVersionProofScript, createPerformanceReadinessConfigScript, createPerformanceReadinessScript, createPublicSurfaceAssetsScript, createWorkspaceI18nBoundaryValidationScript, createWorkspaceValidationScript, writeGeneratedWorkspaceScripts };