@bleedingdev/modern-js-create 3.5.0-ultramodern.4 → 3.5.0-ultramodern.41

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

@@ -1,85 +1,9 @@
 import { WORKSPACE_PACKAGE_VERSION, modernPackageSpecifier } from "../ultramodern-package-source.js";
-import { appHasApi, remoteDependencyAlias, resolveRemoteRefs, sharedPackages, shellApp, verticalApiApps, zephyrRemoteDependency } from "./descriptors.js";
+import { appHasApi, remoteDependencyAlias, resolveRemoteRefs, shellApp, verticalApiApps, zephyrRemoteDependency } from "./descriptors.js";
 import { readFileTemplate } from "./fs-io.js";
 import { packageName, relativeRootFor } from "./naming.js";
-import { createPublicSurfaceGenerationCommand } from "./public-surface.js";
-import { EFFECT_TSGO_VERSION, I18NEXT_VERSION, LEFTHOOK_VERSION, MODULE_FEDERATION_VERSION, NODE_FETCH_VERSION, OXFMT_VERSION, OXLINT_VERSION, PNPM_VERSION, POSTCSS_VERSION, REACT_DOM_VERSION, REACT_ROUTER_VERSION, REACT_VERSION, 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 } from "./versions.js";
-const createStrictTsgoTypecheckCommand = (packageDir)=>`node ${relativeRootFor(packageDir)}/scripts/ultramodern-typecheck.mts --project tsconfig.json`;
-const effectDiagnostics = [
-    'anyUnknownInErrorContext',
-    'classSelfMismatch',
-    'duplicatePackage',
-    'effectFnImplicitAny',
-    'floatingEffect',
-    'genericEffectServices',
-    'missingEffectContext',
-    'missingEffectError',
-    'missingLayerContext',
-    'missingReturnYieldStar',
-    'missingStarInYieldEffectGen',
-    'nonObjectEffectServiceType',
-    'outdatedApi',
-    'overriddenSchemaConstructor',
-    'catchUnfailableEffect',
-    'effectFnIife',
-    'effectGenUsesAdapter',
-    'effectInFailure',
-    'effectInVoidSuccess',
-    'globalErrorInEffectCatch',
-    'globalErrorInEffectFailure',
-    'layerMergeAllWithDependencies',
-    'lazyPromiseInEffectSync',
-    'leakingRequirements',
-    'multipleEffectProvide',
-    'returnEffectInGen',
-    'runEffectInsideEffect',
-    'schemaSyncInEffect',
-    'scopeInLayerEffect',
-    'strictEffectProvide',
-    'tryCatchInEffectGen',
-    'unknownInEffectCatch',
-    'asyncFunction',
-    'cryptoRandomUUID',
-    'cryptoRandomUUIDInEffect',
-    'extendsNativeError',
-    'globalConsole',
-    'globalConsoleInEffect',
-    'globalDate',
-    'globalDateInEffect',
-    'globalFetch',
-    'globalFetchInEffect',
-    'globalRandom',
-    'globalRandomInEffect',
-    'globalTimers',
-    'globalTimersInEffect',
-    'instanceOfSchema',
-    'newPromise',
-    'nodeBuiltinImport',
-    'preferSchemaOverJson',
-    'processEnv',
-    'processEnvInEffect',
-    'unsafeEffectTypeAssertion',
-    'catchAllToMapError',
-    'deterministicKeys',
-    'effectDoNotation',
-    'effectFnOpportunity',
-    'effectMapFlatten',
-    'effectMapVoid',
-    'effectSucceedWithVoid',
-    'missedPipeableOpportunity',
-    'missingEffectServiceDependency',
-    'nestedEffectGenYield',
-    'redundantSchemaTagIdentifier',
-    'schemaStructWithTag',
-    'schemaUnionOfLiterals',
-    'serviceNotAsClass',
-    'strictBooleanExpressions',
-    'unnecessaryArrowBlock',
-    'unnecessaryEffectGen',
-    'unnecessaryFailYieldableError',
-    'unnecessaryPipe',
-    'unnecessaryPipeChain'
-];
+import { EFFECT_TSGO_VERSION, I18NEXT_VERSION, LEFTHOOK_VERSION, MODULE_FEDERATION_VERSION, NODE_FETCH_VERSION, OXFMT_VERSION, OXLINT_VERSION, PNPM_VERSION, REACT_DOM_VERSION, REACT_ROUTER_VERSION, REACT_VERSION, RSBUILD_PLUGIN_TAILWINDCSS_VERSION, TAILWIND_VERSION, TANSTACK_ROUTER_VERSION, TYPESCRIPT_COMPILER_API_VERSION, TYPESCRIPT_VERSION, TYPES_REACT_DOM_VERSION, TYPES_REACT_VERSION, ULTRACITE_VERSION, WRANGLER_VERSION, ZEPHYR_AGENT_VERSION, ZEPHYR_RSPACK_PLUGIN_VERSION } from "./versions.js";
+import { createStrictTsgoTypecheckCommand, createWorkspaceAppPackageScripts, createWorkspaceRootPackageScripts } from "./workspace-script-plan.js";
 function appDependencies(scope, packageSource, app, remotes = [], bridge) {
     const dependencies = {
         '@modern-js/plugin-tanstack': modernPackageSpecifier('@modern-js/plugin-tanstack', packageSource),
@@ -95,10 +19,12 @@ function appDependencies(scope, packageSource, app, remotes = [], bridge) {
         [packageName(scope, 'shared-design-tokens')]: WORKSPACE_PACKAGE_VERSION,
         react: REACT_VERSION,
         'react-dom': REACT_DOM_VERSION,
-        'react-router': REACT_ROUTER_VERSION,
-        'react-router-dom': REACT_ROUTER_VERSION
+        'react-router': REACT_ROUTER_VERSION
     };
-    for (const dependency of bridge?.dependencies ?? [])dependencies[dependency] = WORKSPACE_PACKAGE_VERSION;
+    for (const dependency of bridge?.dependencies ?? []){
+        if (Object.hasOwn(dependencies, dependency)) throw new Error(`Bridge mode dependency "${dependency}" conflicts with generated app dependency.`);
+        dependencies[dependency] = WORKSPACE_PACKAGE_VERSION;
+    }
     if ('shell' === app.kind) {
         dependencies['@modern-js/plugin-bff'] = modernPackageSpecifier('@modern-js/plugin-bff', packageSource);
         for (const remote of verticalApiApps(remotes))dependencies[packageName(scope, remote.packageSuffix)] = WORKSPACE_PACKAGE_VERSION;
@@ -112,11 +38,9 @@ function appDevDependencies(packageSource, enableTailwind) {
         '@modern-js/app-tools': modernPackageSpecifier('@modern-js/app-tools', packageSource),
         '@effect/tsgo': EFFECT_TSGO_VERSION,
         ...enableTailwind ? {
-            '@tailwindcss/postcss': `^${TAILWIND_POSTCSS_VERSION}`,
-            postcss: `^${POSTCSS_VERSION}`,
+            '@rsbuild/plugin-tailwindcss': `^${RSBUILD_PLUGIN_TAILWINDCSS_VERSION}`,
             tailwindcss: `^${TAILWIND_VERSION}`
         } : {},
-        "@typescript/native-preview": TYPESCRIPT_NATIVE_PREVIEW_VERSION,
         '@types/node': '^20',
         '@types/react': TYPES_REACT_VERSION,
         '@types/react-dom': TYPES_REACT_DOM_VERSION,
@@ -128,11 +52,6 @@ function appDevDependencies(packageSource, enableTailwind) {
 function createRootPackageJson(scope, packageSource, remotes = [], bridge) {
     const shellFilter = `--filter ${packageName(scope, shellApp.packageSuffix)}`;
     const remoteFilters = remotes.map((remote)=>`--filter ${packageName(scope, remote.packageSuffix)}`);
-    const remoteBuildPrefix = remotes.length > 0 ? 'ULTRAMODERN_ZEPHYR=false pnpm -r --filter "./verticals/*" run build && ' : '';
-    const remoteCloudflareBuildPrefix = remotes.length > 0 ? 'pnpm -r --filter "./verticals/*" run cloudflare:build && ' : '';
-    const remoteCloudflareDeployPrefix = remotes.length > 0 ? 'pnpm -r --filter "./verticals/*" run cloudflare:deploy && ' : '';
-    const generatedPackageTypecheck = 'pnpm -r --filter "./apps/*" --filter "./verticals/*" --filter "./packages/*" run typecheck';
-    const typecheck = bridge ? generatedPackageTypecheck : "node ./scripts/ultramodern-typecheck.mts --build tsconfig.json";
     const bridgeScripts = bridge ? {
         ...Object.fromEntries(bridge.gates.map((gate)=>[
                 `bridge:${gate.name}`,
@@ -141,6 +60,11 @@ function createRootPackageJson(scope, packageSource, remotes = [], bridge) {
         'bridge:check': bridge.gates.map((gate)=>`pnpm run bridge:${gate.name}`).join(' && ')
     } : {};
     const bridgeCheck = bridge ? ' && pnpm bridge:check' : '';
+    const bridgeTypecheck = bridge ? 'pnpm -r --filter "./apps/*" --filter "./verticals/*" --filter "./packages/*" run typecheck' : void 0;
+    const rootPackageScripts = createWorkspaceRootPackageScripts(remotes, {
+        bridgeCheck,
+        typecheck: bridgeTypecheck
+    });
     const workspacePackages = [
         'apps/*',
         'verticals/*',
@@ -163,28 +87,19 @@ function createRootPackageJson(scope, packageSource, remotes = [], bridge) {
                     `dev:${remote.packageSuffix}`,
                     `pnpm --filter ${packageName(scope, remote.packageSuffix)} dev`
                 ])),
-            build: `${remoteBuildPrefix}ULTRAMODERN_ZEPHYR=false pnpm --filter "./apps/shell-super-app" run build && pnpm mf:types && pnpm performance:readiness`,
+            ...rootPackageScripts,
             format: "oxfmt . '!repos/**'",
             'format:check': "oxfmt --check . '!repos/**'",
             lint: 'oxlint apps verticals packages',
             'lint:fix': 'oxlint apps verticals packages --fix',
-            typecheck,
-            'cloudflare:build': `${remoteCloudflareBuildPrefix}pnpm --filter "./apps/shell-super-app" run cloudflare:build && pnpm mf:types`,
-            'cloudflare:deploy': `${remoteCloudflareDeployPrefix}pnpm --filter "./apps/shell-super-app" run cloudflare:deploy`,
-            'cloudflare:proof': "node ./scripts/proof-cloudflare-version.mts --out .codex/reports/cloudflare-version-proof/public-url-proof.json",
             'skills:install': "node ./scripts/bootstrap-agent-skills.mts",
             'skills:check': "node ./scripts/bootstrap-agent-skills.mts --check",
             'agents:refs:install': "node ./scripts/setup-agent-reference-repos.mts",
             'agents:refs:check': "node ./scripts/setup-agent-reference-repos.mts --check",
-            'mf:types': "node ./scripts/assert-mf-types.mts",
-            'performance:readiness': "node ./scripts/ultramodern-performance-readiness.mts",
-            'migrate:strict-effect': "node ./scripts/migrate-strict-effect.mts",
-            'contract:check': "node ./scripts/validate-ultramodern-workspace.mts",
             'api:check': "node ./scripts/check-ultramodern-api-boundaries.mts",
             'i18n:boundaries': "node ./scripts/check-ultramodern-i18n-boundaries.mts",
             ...bridgeScripts,
-            postinstall: "oxfmt . '!repos/**' && node ./scripts/bootstrap-agent-skills.mts --postinstall",
-            check: `pnpm format:check && pnpm lint && pnpm typecheck && pnpm skills:check && pnpm i18n:boundaries && pnpm api:check && pnpm contract:check && pnpm performance:readiness${bridgeCheck}`
+            postinstall: "oxfmt . '!repos/**' && node ./scripts/bootstrap-agent-skills.mts --postinstall"
         },
         engines: {
             node: '>=26',
@@ -205,7 +120,8 @@ function createRootPackageJson(scope, packageSource, remotes = [], bridge) {
             '@effect/tsgo': EFFECT_TSGO_VERSION,
             '@modern-js/code-tools': modernPackageSpecifier('@modern-js/code-tools', packageSource),
             '@modern-js/create': modernPackageSpecifier('@modern-js/create', packageSource),
-            "@typescript/native-preview": TYPESCRIPT_NATIVE_PREVIEW_VERSION,
+            '@modern-js/plugin-bff': modernPackageSpecifier('@modern-js/plugin-bff', packageSource),
+            "@typescript/typescript6": TYPESCRIPT_COMPILER_API_VERSION,
             lefthook: LEFTHOOK_VERSION,
             oxlint: OXLINT_VERSION,
             oxfmt: OXFMT_VERSION,
@@ -222,144 +138,7 @@ function createZephyrDependencies(scope, app, remotes = []) {
             zephyrRemoteDependency(scope, remote)
         ]));
 }
-function createTsConfigBase() {
-    return {
-        compilerOptions: {
-            target: 'ESNext',
-            lib: [
-                'ESNext',
-                'DOM',
-                'DOM.Iterable'
-            ],
-            module: 'preserve',
-            moduleResolution: 'Bundler',
-            moduleDetection: 'force',
-            jsx: 'preserve',
-            isolatedModules: true,
-            verbatimModuleSyntax: true,
-            strict: true,
-            noEmit: true,
-            allowImportingTsExtensions: true,
-            allowJs: true,
-            esModuleInterop: true,
-            noUncheckedIndexedAccess: true,
-            exactOptionalPropertyTypes: true,
-            noImplicitOverride: true,
-            noFallthroughCasesInSwitch: true,
-            noPropertyAccessFromIndexSignature: true,
-            noImplicitReturns: true,
-            skipLibCheck: true,
-            resolveJsonModule: true,
-            plugins: [
-                {
-                    name: '@effect/language-service',
-                    diagnostics: true,
-                    includeSuggestionsInTsc: true,
-                    ignoreEffectSuggestionsInTscExitCode: false,
-                    ignoreEffectWarningsInTscExitCode: false,
-                    ignoreEffectErrorsInTscExitCode: false,
-                    skipDisabledOptimization: true,
-                    diagnosticSeverity: Object.fromEntries(effectDiagnostics.map((name)=>[
-                            name,
-                            'error'
-                        ]))
-                }
-            ]
-        }
-    };
-}
-function createTsBuildInfoFile(packageDir) {
-    const cacheKey = packageDir.replace(/[^a-zA-Z0-9._-]+/gu, '__');
-    return `${relativeRootFor(packageDir)}/node_modules/.cache/tsgo/${cacheKey}.tsbuildinfo`;
-}
-function createTsDeclarationOutDir(packageDir) {
-    const cacheKey = packageDir.replace(/[^a-zA-Z0-9._-]+/gu, '__');
-    return `${relativeRootFor(packageDir)}/node_modules/.cache/tsgo/declarations/${cacheKey}`;
-}
-function createReferences(packageDir, references) {
-    return [
-        ...new Set(references)
-    ].filter((reference)=>reference !== packageDir).map((reference)=>({
-            path: `${relativeRootFor(packageDir)}/${reference}`
-        }));
-}
-function createPackageTsConfig(packageDir, options = {}) {
-    const resolvedOptions = 'boolean' == typeof options ? {
-        includeApi: options
-    } : options;
-    const include = resolvedOptions.include ?? [
-        'src',
-        'locales/**/*.json',
-        'modern.config.ts',
-        'module-federation.config.ts',
-        'package.json',
-        'shared'
-    ];
-    if (resolvedOptions.includeApi) include.push('api');
-    const references = createReferences(packageDir, resolvedOptions.references ?? []);
-    const tsconfig = {
-        extends: `${relativeRootFor(packageDir)}/tsconfig.base.json`,
-        compilerOptions: {
-            composite: true,
-            declaration: true,
-            declarationMap: false,
-            emitDeclarationOnly: true,
-            incremental: true,
-            noEmit: false,
-            outDir: createTsDeclarationOutDir(packageDir),
-            tsBuildInfoFile: createTsBuildInfoFile(packageDir)
-        },
-        include
-    };
-    if (references.length > 0) tsconfig.references = references;
-    return tsconfig;
-}
-function createAppTsConfig(app, remotes = []) {
-    const references = [
-        ...sharedPackages.map((sharedPackage)=>sharedPackage.directory),
-        ...'shell' === app.kind ? verticalApiApps(remotes).map((remote)=>remote.directory) : resolveRemoteRefs(app, remotes).map((remote)=>remote.directory)
-    ];
-    return createPackageTsConfig(app.directory, {
-        includeApi: appHasApi(app),
-        references
-    });
-}
-function createAppMfTypesTsConfig(app) {
-    const exposedFiles = Object.values(app.exposes ?? {}).map((exposePath)=>exposePath.replace(/^\.\//u, ''));
-    return {
-        extends: './tsconfig.json',
-        include: [
-            ...new Set([
-                ...exposedFiles,
-                'src/modern-app-env.d.ts'
-            ])
-        ]
-    };
-}
-function createSharedPackageTsConfig(packageDir) {
-    return createPackageTsConfig(packageDir, {
-        include: [
-            'src'
-        ]
-    });
-}
-function createRootTsConfig(apps = []) {
-    return {
-        files: [],
-        references: [
-            ...sharedPackages.map((sharedPackage)=>({
-                    path: sharedPackage.directory
-                })),
-            ...apps.map((app)=>({
-                    path: app.directory
-                }))
-        ]
-    };
-}
 function createAppPackage(scope, app, packageSource, enableTailwind, remotes = [], bridge) {
-    const publicSurfaceBuildCommand = createPublicSurfaceGenerationCommand(app, 'dist');
-    const publicSurfaceCloudflareBuildCommand = createPublicSurfaceGenerationCommand(app, 'dist');
-    const publicSurfaceCloudflareOutputCommand = createPublicSurfaceGenerationCommand(app, 'cloudflare');
     const packageExports = Object.fromEntries(Object.entries(app.exposes ?? {}).map(([expose, source])=>[
             expose,
             source
@@ -368,16 +147,7 @@ function createAppPackage(scope, app, packageSource, enableTailwind, remotes = [
         private: true,
         name: packageName(scope, app.packageSuffix),
         version: '0.1.0',
-        scripts: {
-            dev: 'modern dev',
-            build: app.exposes ? `ULTRAMODERN_ZEPHYR=false modern build && ${publicSurfaceBuildCommand} && node ${relativeRootFor(app.directory)}/scripts/assert-mf-types.mts` : `ULTRAMODERN_ZEPHYR=false modern build && ${publicSurfaceBuildCommand}`,
-            'cloudflare:build': `ULTRAMODERN_ZEPHYR=false MODERNJS_DEPLOY=cloudflare modern build && ${publicSurfaceCloudflareBuildCommand} && ULTRAMODERN_ZEPHYR=false MODERNJS_DEPLOY=cloudflare modern deploy && ${publicSurfaceCloudflareOutputCommand}`,
-            'cloudflare:deploy': 'ULTRAMODERN_CLOUDFLARE_REQUIRE_PUBLIC_URLS=true pnpm run cloudflare:build && wrangler deploy --config .output/wrangler.json',
-            'cloudflare:preview': 'pnpm run cloudflare:build && wrangler dev --config .output/wrangler.json',
-            'cloudflare:proof': `node ${relativeRootFor(app.directory)}/scripts/proof-cloudflare-version.mts --app ${app.id}`,
-            serve: 'modern serve',
-            typecheck: createStrictTsgoTypecheckCommand(app.directory)
-        },
+        scripts: createWorkspaceAppPackageScripts(app),
         modernjs: {
             preset: 'presetUltramodern',
             role: 'shell' === app.kind ? 'shell' : 'module-federation-remote',
@@ -415,8 +185,7 @@ function createSharedPackage(scope, id, description) {
             typecheck: createStrictTsgoTypecheckCommand(`packages/${id}`)
         },
         devDependencies: {
-            '@effect/tsgo': EFFECT_TSGO_VERSION,
-            "@typescript/native-preview": TYPESCRIPT_NATIVE_PREVIEW_VERSION
+            '@effect/tsgo': EFFECT_TSGO_VERSION
         }
     };
     if ('shared-design-tokens' === id) packageJson.exports = {
@@ -428,4 +197,5 @@ function createSharedPackage(scope, id, description) {
 function createSharedContractsIndex() {
     return readFileTemplate('packages/shared-contracts-index.ts');
 }
-export { appDependencies, appDevDependencies, createAppMfTypesTsConfig, createAppPackage, createAppTsConfig, createPackageTsConfig, createRootPackageJson, createRootTsConfig, createSharedContractsIndex, createSharedPackage, createSharedPackageTsConfig, createStrictTsgoTypecheckCommand, createTsConfigBase, createZephyrDependencies, effectDiagnostics };
+export { createAppMfTypesTsConfig, createAppTsConfig, createPackageTsConfig, createRootTsConfig, createSharedPackageTsConfig, createTsConfigBase } from "./tsconfigs.js";
+export { appDependencies, createAppPackage, createRootPackageJson, createSharedContractsIndex, createSharedPackage };

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

@@ -145,15 +145,9 @@ const PUBLIC_WEBSITE_POLICY = {
 function formatTsJsonValue(value, indent) {
     return JSON.stringify(value, null, 2).replaceAll('\n', `\n${' '.repeat(indent)}`);
 }
-function formatIntegerCodeLiteral(value) {
-    return String(value).replace(/\B(?=(\d{3})+(?!\d))/gu, '_');
-}
 function createPublicWebsiteQualityGateContract() {
     return PUBLIC_WEBSITE_POLICY.qualityGates;
 }
-function createPublicWebsiteBudgetFallback(budgetName) {
-    return formatIntegerCodeLiteral(PUBLIC_WEBSITE_POLICY.qualityGates.budgets[budgetName]);
-}
 function createPublicHeadRobotsPolicy() {
     return PUBLIC_WEBSITE_POLICY.publicHead;
 }
@@ -180,4 +174,4 @@ function createCloudflareDeployContract(scope, app) {
         }
     };
 }
-export { PUBLIC_WEBSITE_POLICY, createCloudflareDeployContract, createCloudflareProofRoute, createCloudflareSecurityContract, createPublicHeadRobotsPolicy, createPublicSurfaceContentExpansionPolicy, createPublicWebsiteBudgetFallback, createPublicWebsiteQualityGateContract, formatIntegerCodeLiteral, formatTsJsonValue };
+export { createCloudflareDeployContract, createCloudflareSecurityContract, createPublicHeadRobotsPolicy, createPublicSurfaceContentExpansionPolicy, formatTsJsonValue };

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

@@ -180,4 +180,4 @@ function createPublicWebAppArtifacts(app) {
         publicSurface: createPublicSurfaceContract(app)
     };
 }
-export { createLocalisedPublicPath, createPublicHeadContract, createPublicSurfaceContract, createPublicSurfaceGenerationCommand, createPublicSurfaceOutputFiles, createPublicSurfaceRouteEntries, createPublicSurfaceUrlPaths, createPublicWebAppArtifacts, publicSurfaceBaseOutputFiles, publicSurfaceManagedSourceAssetPaths, publicSurfacePublicRouteOutputFiles, rewriteWorkspaceAssetsForApp, uniqueSorted };
+export { createLocalisedPublicPath, createPublicSurfaceGenerationCommand, createPublicWebAppArtifacts, publicSurfaceManagedSourceAssetPaths, rewriteWorkspaceAssetsForApp, uniqueSorted };

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

@@ -1,4 +1,5 @@
 import { appI18nNamespace } from "./descriptors.js";
+import { renderFileTemplate } from "./fs-io.js";
 import { sortJsonValue } from "./types.js";
 const privateAppRoutePublicness = {
     indexable: false,
@@ -76,154 +77,19 @@ 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,
-    })),
-  });
-`;
+    return renderFileTemplate('workspace/apps/shared/src/routes/ultramodern-jsonld.ts', {});
 }
 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;
-`;
+    return renderFileTemplate('workspace/apps/shared/src/routes/ultramodern-route-metadata.ts', {
+        value0: namespace,
+        value1: JSON.stringify(routes, null, 2),
+        value2: JSON.stringify(localisedUrls, null, 2),
+        value3: JSON.stringify(publicRoutes, null, 2)
+    });
 }
 function createRouteMetaModule(route) {
     return `const routeMeta = ${JSON.stringify(sortJsonValue(route), null, 2)} as const;
@@ -277,4 +143,4 @@ function createRouteAliasPage(canonicalPath) {
     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 };
+export { createJsonLdHelperModule, createLocalisedUrlsMap, createPublicRouteMetadata, createPublicRouteMetadataFromRoutes, createRouteAliasPage, createRouteMetaFilePath, createRouteMetaModule, createRouteMetadataModule, createRouteOwnedI18nPaths, createRoutePageFilePath, isConcretePublicPath, normalisePublicPath, routePathParamName, routeSegmentToDirectory, splitPublicPathSegments };

package/dist/esm/ultramodern-workspace/shared-patches.js

@@ -0,0 +1,7 @@
+const SHARED_ULTRAMODERN_WORKSPACE_PATCH_FILES = [
+    '@module-federation__bridge-react@2.7.0.patch',
+    '@module-federation__dts-plugin@2.7.0.patch',
+    '@module-federation__modern-js-v3@2.7.0.patch',
+    '@tanstack__router-core@1.171.14.patch'
+];
+export { SHARED_ULTRAMODERN_WORKSPACE_PATCH_FILES };

package/dist/esm/ultramodern-workspace/tooling-command-catalog.js

@@ -0,0 +1,100 @@
+const defineToolingCommand = (command)=>({
+        ...command,
+        wrapperPath: `scripts/${command.wrapperName}.mts`
+    });
+const generatedToolingCommands = [
+    defineToolingCommand({
+        id: 'validate',
+        command: 'validate',
+        wrapperName: 'validate-ultramodern-workspace',
+        contractKey: 'validate',
+        rootScript: 'contract:check'
+    }),
+    defineToolingCommand({
+        id: 'typecheck',
+        command: 'typecheck',
+        wrapperName: 'ultramodern-typecheck',
+        contractKey: 'typecheck',
+        rootScript: 'typecheck',
+        templatePath: "templates/workspace-scripts/ultramodern-typecheck.mjs",
+        cwd: 'invocation'
+    }),
+    defineToolingCommand({
+        id: 'mfTypes',
+        command: 'mf-types',
+        wrapperName: 'assert-mf-types',
+        contractKey: 'mfTypes',
+        rootScript: 'mf:types'
+    }),
+    defineToolingCommand({
+        id: 'publicSurface',
+        command: 'public-surface',
+        wrapperName: 'generate-public-surface-assets',
+        contractKey: 'publicSurface',
+        templatePath: "templates/workspace-scripts/generate-public-surface-assets.mjs"
+    }),
+    defineToolingCommand({
+        id: 'backendFederationGenerate',
+        command: 'backend-federation-generate',
+        wrapperName: 'generate-node-backend-federation',
+        contractKey: 'backendFederationGenerate',
+        rootScript: 'node:backend-federation:generate',
+        templatePath: "templates/workspace-scripts/generate-node-backend-federation.mjs"
+    }),
+    defineToolingCommand({
+        id: 'backendFederationProof',
+        command: 'backend-federation-proof',
+        wrapperName: 'proof-node-backend-federation',
+        contractKey: 'backendFederationProof',
+        rootScript: 'node:proof',
+        templatePath: "templates/workspace-scripts/proof-node-backend-federation.mjs"
+    }),
+    defineToolingCommand({
+        id: 'cloudflareProof',
+        command: 'cloudflare-proof',
+        wrapperName: 'proof-cloudflare-version',
+        contractKey: 'cloudflareProof',
+        rootScript: 'cloudflare:proof',
+        templatePath: "templates/workspace-scripts/proof-cloudflare-version.mjs"
+    }),
+    defineToolingCommand({
+        id: 'cloudflareOutputVerify',
+        command: 'cloudflare-output-verify',
+        wrapperName: 'verify-cloudflare-output',
+        contractKey: 'cloudflareOutputVerify',
+        rootScript: 'cloudflare-output:verify'
+    }),
+    defineToolingCommand({
+        id: 'performanceReadiness',
+        command: 'performance-readiness',
+        wrapperName: 'ultramodern-performance-readiness',
+        contractKey: 'performanceReadiness',
+        rootScript: 'performance:readiness',
+        templatePath: "templates/workspace-scripts/ultramodern-performance-readiness.mjs"
+    }),
+    defineToolingCommand({
+        id: 'migrateStrictEffect',
+        command: 'migrate-strict-effect',
+        wrapperName: 'migrate-strict-effect',
+        contractKey: 'migrateStrictEffect',
+        rootScript: 'migrate:strict-effect'
+    }),
+    defineToolingCommand({
+        id: 'routesGenerate',
+        command: 'routes-generate',
+        wrapperName: 'generate-tanstack-routes',
+        contractKey: 'routesGenerate'
+    })
+];
+const toolingCommandById = Object.fromEntries(generatedToolingCommands.map((command)=>[
+        command.id,
+        command
+    ]));
+const GENERATED_TOOLING_COMMANDS = toolingCommandById;
+const generatedToolingCommandList = ()=>generatedToolingCommands.map((command)=>command.command);
+const createToolingWrapperContract = ()=>Object.fromEntries(generatedToolingCommands.map((command)=>[
+            command.contractKey,
+            command.wrapperPath
+        ]));
+const createGeneratedToolingWrapperMap = createToolingWrapperContract;
+export { GENERATED_TOOLING_COMMANDS, createGeneratedToolingWrapperMap, generatedToolingCommandList, generatedToolingCommands };