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

package/dist/cjs/ultramodern-workspace/validation/workspace.cjs

@@ -0,0 +1,344 @@
+"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__, {
+    validateApiClientExports: ()=>validateApiClientExports,
+    validateApiOnlySourceSurface: ()=>validateApiOnlySourceSurface,
+    validateBackendFederationEntrypoints: ()=>validateBackendFederationEntrypoints,
+    validateWorkspace: ()=>validateWorkspace
+});
+const external_node_fs_namespaceObject = require("node:fs");
+var external_node_fs_default = /*#__PURE__*/ __webpack_require__.n(external_node_fs_namespaceObject);
+const external_node_path_namespaceObject = require("node:path");
+var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
+const utils_namespaceObject = require("@modern-js/utils");
+const external_ultramodern_release_cohort_cjs_namespaceObject = require("../../ultramodern-release-cohort.cjs");
+const external_architecture_cjs_namespaceObject = require("./architecture.cjs");
+function assert(condition, message) {
+    if (!condition) throw new Error(message);
+}
+function record(value, label) {
+    assert(null !== value && 'object' == typeof value && !Array.isArray(value), `${label} must be an object`);
+    return value;
+}
+function entries(value, label) {
+    assert(Array.isArray(value), `${label} must be an array`);
+    return value.map((entry, index)=>record(entry, `${label}[${index}]`));
+}
+function distinct(values, label) {
+    assert(new Set(values).size === values.length, `${label} contains duplicate entries`);
+}
+function requiredFile(root, relative, label) {
+    assert(external_node_fs_default().existsSync(external_node_path_default().join(root, relative)), `${label} is missing: ${relative}`);
+}
+function developmentUrl(value, port, label, generatedPath) {
+    assert('string' == typeof value, `${label} must be a URL`);
+    let parsed;
+    try {
+        parsed = new URL(value);
+    } catch  {
+        throw new Error(`${label} must be a URL`);
+    }
+    assert([
+        'http:',
+        'https:'
+    ].includes(parsed.protocol) && parsed.hostname.length > 0, `${label} must be an HTTP URL`);
+    if (generatedPath && parsed.pathname === generatedPath && ('localhost' === parsed.hostname || '127.0.0.1' === parsed.hostname)) assert(Number(parsed.port) === port, `${label} must use the app development port ${port}`);
+    return parsed;
+}
+function safePath(root, relative, label) {
+    assert('string' == typeof relative && relative.length > 0 && !external_node_path_default().isAbsolute(relative), `${label} must be a relative path`);
+    const resolved = external_node_path_default().resolve(root, relative);
+    assert(resolved.startsWith(`${external_node_path_default().resolve(root)}${external_node_path_default().sep}`), `${label} leaves the workspace`);
+    const realRoot = external_node_fs_default().realpathSync(root);
+    const real = external_node_fs_default().realpathSync(resolved);
+    assert(real.startsWith(`${realRoot}${external_node_path_default().sep}`), `${label} resolves outside the workspace`);
+    return resolved;
+}
+function validateApiClientExports(root, appPath, appId, exports1) {
+    const clients = [
+        './api/client',
+        './api/rpc-client'
+    ].map((key)=>exports1?.[key]).filter((value)=>void 0 !== value);
+    assert(clients.length > 0, `${appId} must export its API client`);
+    for (const client of clients){
+        assert('string' == typeof client && client.startsWith('./') && !client.split(/[\\/]/u).includes('..') && /\.[cm]?[jt]sx?$/u.test(client), `${appId} must export its API client from an app-owned source module`);
+        assert(external_node_fs_default().existsSync(external_node_path_default().join(root, appPath, client)), `${appId} API client is missing: ${client}`);
+        const clientFile = safePath(external_node_path_default().join(root, appPath), client, `${appId} API client`);
+        assert(external_node_fs_default().statSync(clientFile).isFile(), `${appId} API client must be a file`);
+    }
+}
+function validateApiOnlySourceSurface(root, app) {
+    assert(!Object.hasOwn(app.backendFederation?.versionBoundary ?? {}, 'ui'), `topology/reference-topology.json verticals.${app.id}.backendFederation must omit the UI boundary for an api-only unit`);
+    for (const relative of [
+        'module-federation.config.ts',
+        'src/federation-entry.tsx',
+        `src/components/${app.id}-widget.tsx`,
+        'src/routes/layout.tsx',
+        'src/routes/[lang]/page.tsx',
+        'src/routes/[lang]/route.meta.ts',
+        'src/routes/ultramodern-route-metadata.ts',
+        'src/routes/ultramodern-route-head.tsx',
+        'src/routes/index.css'
+    ])assert(!external_node_fs_default().existsSync(external_node_path_default().join(root, app.path, relative)), `Unexpected ${app.path}/${relative} for a api-only unit`);
+    const mfTypesPath = external_node_path_default().join(root, app.path, 'tsconfig.mf-types.json');
+    if (external_node_fs_default().existsSync(mfTypesPath)) {
+        const mfTypes = record(JSON.parse(external_node_fs_default().readFileSync(mfTypesPath, 'utf8')), `${app.id} tsconfig.mf-types.json`);
+        assert(!mfTypes.include?.includes('src/federation-entry.tsx'), `${app.id}: restore the generated MicroVertical Module Federation DTS boundary`);
+    }
+}
+function validateBackendFederationEntrypoints(root, appPath, appId) {
+    for (const relative of [
+        'backend-federation.config.ts',
+        'api/index.ts',
+        'api/effect-api.ts'
+    ])requiredFile(root, `${appPath}/${relative}`, `${appId} API surface`);
+}
+function validateWorkspace(root, expected) {
+    const readJson = (relative)=>record(JSON.parse(external_node_fs_default().readFileSync(safePath(root, relative, relative), 'utf8')), relative);
+    const topology = readJson('topology/reference-topology.json');
+    const ownership = readJson('topology/ownership.json');
+    const overlay = readJson('topology/local-overlays/development.json');
+    const rootManifest = readJson('package.json');
+    const workspace = record(utils_namespaceObject.yaml.load(external_node_fs_default().readFileSync(external_node_path_default().join(root, 'pnpm-workspace.yaml'), 'utf8')), 'pnpm-workspace.yaml');
+    for (const [label, value] of [
+        [
+            'topology',
+            topology
+        ],
+        [
+            'ownership',
+            ownership
+        ],
+        [
+            'overlay',
+            overlay
+        ]
+    ])assert(1 === value.schemaVersion, `${label} schemaVersion must be 1`);
+    assert(rootManifest.name === expected.packageScope, 'Root package name disagrees with the workspace scope');
+    const shell = record(topology.shell, 'topology.shell');
+    const verticals = entries(topology.verticals, 'topology.verticals');
+    const shells = [
+        shell,
+        ...entries(topology.shells ?? [], 'topology.shells')
+    ];
+    const apps = [
+        ...shells,
+        ...verticals
+    ];
+    const shared = entries(topology.sharedPackages ?? [], 'topology.sharedPackages');
+    const owners = entries(ownership.owners, 'ownership.owners');
+    distinct(apps.map((app)=>app.id), 'topology app ids');
+    distinct([
+        ...apps,
+        ...shared
+    ].map((app)=>app.path), 'topology package paths');
+    distinct(shared.map((pkg)=>pkg.id), 'topology shared package ids');
+    distinct(owners.map((owner)=>owner.id), 'ownership ids');
+    assert(shared.length === expected.sharedPackages.length, 'Shared package membership disagrees with canonical inputs');
+    for (const expectedShared of expected.sharedPackages){
+        const actual = shared.find((entry)=>entry.id === expectedShared.id);
+        assert(actual?.path === expectedShared.path && actual?.package === expectedShared.packageName, `${expectedShared.id} shared package identity disagrees with canonical inputs`);
+    }
+    const expectedApps = new Map(expected.apps.map((app)=>[
+            app.id,
+            app
+        ]));
+    assert(apps.length === expectedApps.size, 'Topology app membership disagrees with canonical inputs');
+    const verticalIds = new Set(verticals.map((vertical)=>vertical.id));
+    const ids = new Set(apps.map((app)=>app.id));
+    for (const app of apps){
+        const input = expectedApps.get(app.id);
+        assert(input, `Unexpected topology app ${app.id}`);
+        assert(app.kind === input.kind, `${app.id} kind disagrees with canonical inputs`);
+        assert(app.path === input.path, `${app.id} path disagrees with canonical inputs`);
+        assert(app.package === input.packageName, `${app.id} package identity disagrees with canonical inputs`);
+        const manifest = readJson(`${app.path}/package.json`);
+        assert(manifest.name === app.package, `${app.id} package name contradicts topology`);
+        assert(manifest.modernjs?.appId === app.id, `${app.id} modernjs.appId contradicts topology`);
+        const owner = owners.find((candidate)=>candidate.id === app.id);
+        assert(owner?.path === app.path && owner?.package === manifest.name, `${app.id} ownership identity contradicts topology and package.json`);
+        const refs = app.moduleFederation?.verticalRefs ?? app.verticalRefs ?? [];
+        assert(Array.isArray(refs), `${app.id} verticalRefs must be an array`);
+        distinct(refs, `${app.id} verticalRefs`);
+        for (const ref of refs)assert(verticalIds.has(ref), `${app.id} references unknown vertical ${ref}`);
+        assert(JSON.stringify(refs) === JSON.stringify(input.verticalRefs), `${app.id} verticalRefs disagree with canonical inputs`);
+        const port = overlay.ports?.[app.id];
+        assert(Number.isInteger(port) && port > 0 && port < 65536, `${app.id} has no development port`);
+        requiredFile(root, `${app.path}/modern.config.ts`, `${app.id} Modern.js config`);
+        if (input.emitsUi) requiredFile(root, `${app.path}/src/modern.runtime.ts`, `${app.id} runtime`);
+        requiredFile(root, `${app.path}/shared/ultramodern-build.json`, `${app.id} build stamp`);
+        const cloudflare = record(app.cloudflare, `${app.id} cloudflare`);
+        for (const field of [
+            'workerName',
+            'publicUrlEnv'
+        ])assert('string' == typeof cloudflare[field] && cloudflare[field].length > 0, `${app.id} cloudflare.${field} is required`);
+        const cloudflareRoutes = record(cloudflare.routes, `${app.id} cloudflare.routes`);
+        record(cloudflare.security, `${app.id} cloudflare.security`);
+        record(cloudflare.qualityGates, `${app.id} cloudflare.qualityGates`);
+        if ('shell' === app.kind) assert('string' == typeof cloudflareRoutes.ssr && cloudflareRoutes.ssr.startsWith('/'), `${app.id} cloudflare SSR route is required`);
+        if (input.emitsApi) {
+            const routeKey = app.api?.protocol === 'rpc' ? 'rpc' : 'apiReadiness';
+            assert('string' == typeof cloudflareRoutes[routeKey] && cloudflareRoutes[routeKey].startsWith('/'), `${app.id} cloudflare API ${routeKey} route is required`);
+        }
+        if (input.emitsUi && 'shell' !== app.kind) {
+            assert('string' == typeof overlay.manifests?.[app.id], `${app.id} has no development MF manifest URL`);
+            developmentUrl(overlay.manifests[app.id], port, `${app.id} MF manifest URL`, '/mf-manifest.json');
+            requiredFile(root, `${app.path}/module-federation.config.ts`, `${app.id} Module Federation config`);
+            for (const [expose, relative] of Object.entries(input.exposes)){
+                assert('string' == typeof relative && relative.startsWith('./src/'), `${app.id} ${expose} Module Federation expose must target a source file`);
+                assert(external_node_fs_default().existsSync(external_node_path_default().join(root, app.path, relative)), `${app.id} ${expose} Module Federation expose source ${relative} is missing`);
+            }
+        }
+        if (input.emitsApi) assert('string' == typeof overlay.apis?.[app.id], `${app.id} has no development API URL`);
+        if (input.emitsApi && 'vertical' === app.kind) {
+            const apiUrl = developmentUrl(overlay.apis[app.id], port, `${app.id} API URL`);
+            const serverExecution = record(overlay.serverExecution?.[app.id], `${app.id} server execution`);
+            assert(serverExecution.apiBaseUrl === apiUrl.href.replace(/\/$/, ''), `${app.id} server execution API URL disagrees with overlay`);
+            const backend = record(app.backendFederation, `${app.id} backendFederation`);
+            const node = record(backend.executionSurfaces?.node, `${app.id} backendFederation node`);
+            developmentUrl(node.manifestUrl, port, `${app.id} backend manifest URL`, '/backend-mf-manifest.json');
+            developmentUrl(node.containerEntry, port, `${app.id} backend container URL`, '/backendRemoteEntry.cjs');
+            validateBackendFederationEntrypoints(root, app.path, app.id);
+            const apiExport = manifest.exports?.['./api'];
+            assert('string' == typeof apiExport && apiExport.startsWith('./shared/'), `${app.id} must export its shared API contract`);
+            assert(external_node_fs_default().existsSync(external_node_path_default().join(root, app.path, apiExport)), `${app.id} shared API contract ${apiExport} is missing`);
+            validateApiClientExports(root, app.path, app.id, manifest.exports);
+            const backendDelivery = record(backend.deliveryUnit, `${app.id} backendFederation.deliveryUnit`);
+            assert(backendDelivery.unitId === app.deliveryUnit?.unitId && backendDelivery.packageName === manifest.name && backendDelivery.buildMarker === app.deliveryUnit?.buildMarker, `${app.id} backend federation delivery identity contradicts topology`);
+            assert(backend.versionBoundary?.identityRoot === 'deliveryUnit' && backend.versionBoundary?.packageName === manifest.name, `${app.id} backend federation version boundary contradicts topology`);
+            assert(node.expected?.unitId === app.deliveryUnit?.unitId && node.expected?.buildMarker === app.deliveryUnit?.buildMarker, `${app.id} backend federation node identity contradicts topology`);
+            assert(serverExecution.deliveryUnit?.unitId === app.deliveryUnit?.unitId && serverExecution.deliveryUnit?.buildMarker === app.deliveryUnit?.buildMarker, `${app.id} server execution identity contradicts topology`);
+            assert(serverExecution.node?.manifestUrl === node.manifestUrl && serverExecution.node?.containerEntry === node.containerEntry, `${app.id} server execution node endpoints contradict topology`);
+        }
+        if ('vertical' === app.kind && !input.emitsUi) validateApiOnlySourceSurface(root, app);
+        if ('vertical' === app.kind && !input.emitsApi) {
+            assert(!Object.hasOwn(overlay.apis ?? {}, app.id) && !Object.hasOwn(overlay.serverExecution ?? {}, app.id), `${app.id} UI-only vertical must not declare API endpoints`);
+            assert(!app.backendFederation && !app.api, `${app.id} UI-only vertical must not declare a backend API`);
+            for (const relative of [
+                'shared/api.ts',
+                'shared/rpc.ts',
+                'backend-federation.config.ts',
+                'api/index.ts',
+                'api/effect-api.ts',
+                'api/backend-federation.ts',
+                `src/api/${app.id}-client.ts`,
+                `src/api/${app.id}-rpc-client.ts`
+            ])assert(!external_node_fs_default().existsSync(external_node_path_default().join(root, app.path, relative)), `Unexpected ${app.path}/${relative} for a ui-only unit`);
+        }
+        const delivery = record(app.deliveryUnit, `${app.id} deliveryUnit`);
+        assert('string' == typeof delivery.unitId && delivery.unitId.length > 0 && delivery.packageName === manifest.name, `${app.id} delivery unit identity contradicts package.json`);
+        const build = readJson(`${app.path}/shared/ultramodern-build.json`);
+        assert(build.deliveryUnit?.unitId === delivery.unitId && build.deliveryUnit?.packageName === manifest.name && build.deliveryUnit?.buildMarker === delivery.buildMarker, `${app.id} build identity contradicts topology`);
+    }
+    for (const pkg of shared){
+        const manifest = readJson(`${pkg.path}/package.json`);
+        assert(manifest.name === pkg.package, `${pkg.id} shared package identity contradicts topology`);
+        assert(owners.some((owner)=>owner.id === pkg.id && owner.path === pkg.path && owner.package === manifest.name), `${pkg.id} ownership identity contradicts package.json`);
+    }
+    for (const owner of owners)assert(ids.has(owner.id) || shared.some((pkg)=>pkg.id === owner.id), `Ownership names unknown package ${owner.id}`);
+    const catalogs = record(workspace.catalogs ?? {}, 'workspace catalogs');
+    const catalog = record(catalogs.ultramodern ?? {}, 'ultramodern catalog');
+    const producer = (0, external_ultramodern_release_cohort_cjs_namespaceObject.hasCreateReleaseCohort)() ? (0, external_ultramodern_release_cohort_cjs_namespaceObject.readCreateReleaseCohort)() : void 0;
+    const sourceCheckout = (0, external_ultramodern_release_cohort_cjs_namespaceObject.isCreatePackageSourceCheckout)();
+    const cohort = new Map(producer?.packages.map((pkg)=>[
+            pkg.sourceName,
+            pkg
+        ]) ?? []);
+    const members = [
+        ...apps,
+        ...shared
+    ].map((app)=>`${app.path}/package.json`);
+    members.push('package.json');
+    for (const member of members){
+        const manifest = readJson(member);
+        for (const group of [
+            'dependencies',
+            'devDependencies',
+            'optionalDependencies',
+            'peerDependencies'
+        ])for (const [name, request] of Object.entries(record(manifest[group] ?? {}, `${member} ${group}`))){
+            if (!expected.modernPackages.includes(name)) continue;
+            assert('string' == typeof request, `${member} ${name} dependency request must be a string`);
+            const catalogRequest = 'catalog:ultramodern' === request ? catalog[name] : void 0;
+            const effective = catalogRequest ?? request;
+            assert('string' == typeof effective && effective.length > 0, `${member} ${name} has no catalog entry`);
+            if ('workspace:*' !== request) assert('catalog:ultramodern' === request, `${member} ${name} must use the ultramodern catalog`);
+            assert(producer || sourceCheckout || 'workspace:*' === request, `${member} ${name} uses the ultramodern catalog, but the installed ultramodern-create package is missing release-cohort.json. Install a published ultramodern-create release, or generate with --ultramodern-package-source workspace.`);
+            if (producer && 'workspace:*' !== request) {
+                const release = cohort.get(name);
+                assert(release, `${member} ${name} is absent from the installed release cohort`);
+                assert(effective === `npm:${release.targetName}@${release.version}`, `${member} ${name} catalog request disagrees with the installed release cohort`);
+            }
+            let memberDir = external_node_path_default().dirname(external_node_path_default().join(root, member));
+            let installedPath;
+            while(memberDir.startsWith(external_node_path_default().resolve(root))){
+                const candidate = external_node_path_default().join(memberDir, 'node_modules', name, 'package.json');
+                if (external_node_fs_default().existsSync(candidate)) {
+                    installedPath = candidate;
+                    break;
+                }
+                if (memberDir === external_node_path_default().resolve(root)) break;
+                memberDir = external_node_path_default().dirname(memberDir);
+            }
+            if ('workspace:*' !== request && external_node_fs_default().existsSync(external_node_path_default().join(root, 'node_modules'))) assert(installedPath, `${member} ${name} is not installed`);
+            if (installedPath && 'workspace:*' !== request) {
+                const installed = record(JSON.parse(external_node_fs_default().readFileSync(installedPath, 'utf8')), installedPath);
+                const aliasMatch = /^npm:(@[^/]+\/[^@]+)@(.+)$/u.exec(effective);
+                assert(aliasMatch, `${member} ${name} catalog entry must name an installed package and version`);
+                assert(installed.name === aliasMatch[1] && installed.version === aliasMatch[2], `${member} ${name} installed package identity/version disagrees with the catalog`);
+                if (producer) assert(installed.version === producer.release.version, `${member} ${name} installed version disagrees with the release cohort`);
+            }
+        }
+    }
+    (0, external_architecture_cjs_namespaceObject.assertCompilerArchitecture)(root, expected);
+    console.log('UltraModern workspace validated');
+}
+exports.validateApiClientExports = __webpack_exports__.validateApiClientExports;
+exports.validateApiOnlySourceSurface = __webpack_exports__.validateApiOnlySourceSurface;
+exports.validateBackendFederationEntrypoints = __webpack_exports__.validateBackendFederationEntrypoints;
+exports.validateWorkspace = __webpack_exports__.validateWorkspace;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "validateApiClientExports",
+    "validateApiOnlySourceSurface",
+    "validateBackendFederationEntrypoints",
+    "validateWorkspace"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/ultramodern-workspace/versions.cjs

@@ -27,57 +27,99 @@ var __webpack_require__ = {};
 })();
 var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
-const TANSTACK_ROUTER_VERSION = '1.170.33';
-const TANSTACK_ROUTER_CORE_VERSION = '1.171.28';
-const TANSTACK_HISTORY_VERSION = '1.162.2';
-const MODULE_FEDERATION_VERSION = '2.9.0';
-const ZEPHYR_RSPACK_PLUGIN_VERSION = '1.2.4';
-const ZEPHYR_AGENT_VERSION = '1.2.4';
-const WRANGLER_VERSION = '4.116.0';
+const TANSTACK_ROUTER_VERSION = '1.170.39';
+const TANSTACK_ROUTER_CORE_VERSION = '1.171.32';
+const TANSTACK_HISTORY_VERSION = '1.162.4';
+const MODULE_FEDERATION_VERSION = '2.9.2';
+const MODULE_FEDERATION_MODERN_JS_V3_FORK_VERSION = '2.9.3';
+const ZEPHYR_RSPACK_PLUGIN_VERSION = '1.4.0';
+const ZEPHYR_AGENT_VERSION = '1.4.0';
+const WRANGLER_VERSION = '4.137.0';
 const CLOUDFLARE_COMPATIBILITY_DATE = '2026-06-02';
 const TAILWIND_VERSION = '4.3.3';
 const RSBUILD_PLUGIN_TAILWINDCSS_VERSION = '2.0.3';
-const EFFECT_VERSION = '4.0.0-rc.112';
-const EFFECT_VITEST_VERSION = '4.0.0-rc.112';
-const EFFECT_TSGO_VERSION = '0.41.0';
-const MSGPACKR_VERSION = '2.1.0';
-const ZOD_VERSION = '4.5.4';
-const DRIZZLE_ORM_VERSION = '1.0.0-rc.4';
+const EFFECT_VERSION = '4.0.0-rc.117';
+const EFFECT_TSGO_VERSION = '0.45.0';
 const TYPESCRIPT_STABLE_VERSION = '7.0.2';
 const TYPESCRIPT_VERSION = TYPESCRIPT_STABLE_VERSION;
 const TYPESCRIPT_NATIVE_PREVIEW_VERSION = '7.0.0-dev.20260707.2';
-const OXLINT_VERSION = '1.81.0';
-const OXFMT_VERSION = '0.66.0';
-const ULTRACITE_VERSION = '7.11.0';
-const CROSS_ENV_VERSION = '10.1.0';
-const LEFTHOOK_VERSION = '^2.1.10';
+const OXLINT_VERSION = '1.85.0';
+const OXFMT_VERSION = '0.70.0';
+const ULTRACITE_VERSION = '7.12.0';
+const LEFTHOOK_VERSION = '^2.1.14';
 const I18NEXT_VERSION = '26.4.2';
-const MODULE_FEDERATION_NODE_VERSION = '2.7.50';
-const MINIFLARE_VERSION = '4.20260730.0';
-const WORKERD_VERSION = '1.20260730.1';
-const CLOUDFLARE_WORKERS_TYPES_VERSION = '5.20260906.1';
+const MODULE_FEDERATION_NODE_VERSION = '2.7.52';
+const MINIFLARE_VERSION = '5.20260921.0-alpha';
+const WORKERD_VERSION = '1.20260921.1';
+const CLOUDFLARE_WORKERS_TYPES_VERSION = '5.20260923.1';
 const NODE_FETCH_VERSION = '^3.3.2';
-const REACT_VERSION = '19.2.8';
-const REACT_DOM_VERSION = '19.2.8';
-const TYPES_NODE_VERSION = '^26.4.1';
-const TYPES_REACT_VERSION = '^19.2.18';
-const TYPES_REACT_DOM_VERSION = '^19.2.7';
+const REACT_VERSION = '19.3.0';
+const REACT_DOM_VERSION = '19.3.0';
+const TYPES_NODE_VERSION = '^26.6.2';
+const TYPES_REACT_VERSION = '^19.3.0';
+const TYPES_REACT_DOM_VERSION = '^19.3.0';
 const NODE_VERSION = '26.7.0';
-const PNPM_VERSION = '11.24.0';
+const PNPM_VERSION = '11.27.1';
+const ULTRAMODERN_PACKAGE_PINS = {
+    appDependencies: {
+        '@module-federation/bridge-react': `npm:@bleedingdev/mf-bridge-react@${MODULE_FEDERATION_VERSION}`,
+        '@module-federation/modern-js-v3': `npm:@bleedingdev/mf-modern-js-v3@${MODULE_FEDERATION_MODERN_JS_V3_FORK_VERSION}`,
+        '@module-federation/runtime': `npm:@bleedingdev/mf-runtime@${MODULE_FEDERATION_VERSION}`,
+        '@tanstack/react-router': TANSTACK_ROUTER_VERSION,
+        i18next: I18NEXT_VERSION,
+        'node-fetch': NODE_FETCH_VERSION,
+        react: REACT_VERSION,
+        'react-dom': REACT_DOM_VERSION
+    },
+    bffEffectDependencies: {
+        '@effect/opentelemetry': EFFECT_VERSION,
+        effect: EFFECT_VERSION
+    },
+    appDevDependencies: {
+        '@effect/tsgo': EFFECT_TSGO_VERSION,
+        '@rsbuild/plugin-tailwindcss': `^${RSBUILD_PLUGIN_TAILWINDCSS_VERSION}`,
+        "@typescript/native": `npm:typescript@${TYPESCRIPT_VERSION}`,
+        '@types/node': TYPES_NODE_VERSION,
+        '@types/react': TYPES_REACT_VERSION,
+        '@types/react-dom': TYPES_REACT_DOM_VERSION,
+        tailwindcss: `^${TAILWIND_VERSION}`,
+        typescript: TYPESCRIPT_VERSION,
+        wrangler: WRANGLER_VERSION,
+        'zephyr-rspack-plugin': ZEPHYR_RSPACK_PLUGIN_VERSION
+    },
+    rootDevDependencies: {
+        '@effect/tsgo': EFFECT_TSGO_VERSION,
+        "@typescript/native": `npm:typescript@${TYPESCRIPT_VERSION}`,
+        '@types/node': TYPES_NODE_VERSION,
+        lefthook: LEFTHOOK_VERSION,
+        miniflare: MINIFLARE_VERSION,
+        oxlint: OXLINT_VERSION,
+        oxfmt: OXFMT_VERSION,
+        ultracite: ULTRACITE_VERSION,
+        wrangler: WRANGLER_VERSION,
+        'zephyr-agent': ZEPHYR_AGENT_VERSION
+    },
+    transitiveDependencies: {
+        '@cloudflare/workers-types': CLOUDFLARE_WORKERS_TYPES_VERSION,
+        '@module-federation/node': MODULE_FEDERATION_NODE_VERSION,
+        '@tanstack/history': TANSTACK_HISTORY_VERSION,
+        '@tanstack/router-core': TANSTACK_ROUTER_CORE_VERSION,
+        "@typescript/native-preview": TYPESCRIPT_NATIVE_PREVIEW_VERSION,
+        miniflare: MINIFLARE_VERSION,
+        workerd: WORKERD_VERSION
+    }
+};
 __webpack_require__.d(__webpack_exports__, {}, {
     CLOUDFLARE_COMPATIBILITY_DATE: CLOUDFLARE_COMPATIBILITY_DATE,
     CLOUDFLARE_WORKERS_TYPES_VERSION: CLOUDFLARE_WORKERS_TYPES_VERSION,
-    CROSS_ENV_VERSION: CROSS_ENV_VERSION,
-    DRIZZLE_ORM_VERSION: DRIZZLE_ORM_VERSION,
     EFFECT_TSGO_VERSION: EFFECT_TSGO_VERSION,
     EFFECT_VERSION: EFFECT_VERSION,
-    EFFECT_VITEST_VERSION: EFFECT_VITEST_VERSION,
     I18NEXT_VERSION: I18NEXT_VERSION,
     LEFTHOOK_VERSION: LEFTHOOK_VERSION,
     MINIFLARE_VERSION: MINIFLARE_VERSION,
+    MODULE_FEDERATION_MODERN_JS_V3_FORK_VERSION: MODULE_FEDERATION_MODERN_JS_V3_FORK_VERSION,
     MODULE_FEDERATION_NODE_VERSION: MODULE_FEDERATION_NODE_VERSION,
     MODULE_FEDERATION_VERSION: MODULE_FEDERATION_VERSION,
-    MSGPACKR_VERSION: MSGPACKR_VERSION,
     NODE_FETCH_VERSION: NODE_FETCH_VERSION,
     NODE_VERSION: NODE_VERSION,
     OXFMT_VERSION: OXFMT_VERSION,
@@ -97,25 +139,22 @@ __webpack_require__.d(__webpack_exports__, {}, {
     TYPES_REACT_DOM_VERSION: TYPES_REACT_DOM_VERSION,
     TYPES_REACT_VERSION: TYPES_REACT_VERSION,
     ULTRACITE_VERSION: ULTRACITE_VERSION,
+    ULTRAMODERN_PACKAGE_PINS: ULTRAMODERN_PACKAGE_PINS,
     WORKERD_VERSION: WORKERD_VERSION,
     WRANGLER_VERSION: WRANGLER_VERSION,
     ZEPHYR_AGENT_VERSION: ZEPHYR_AGENT_VERSION,
-    ZEPHYR_RSPACK_PLUGIN_VERSION: ZEPHYR_RSPACK_PLUGIN_VERSION,
-    ZOD_VERSION: ZOD_VERSION
+    ZEPHYR_RSPACK_PLUGIN_VERSION: ZEPHYR_RSPACK_PLUGIN_VERSION
 });
 exports.CLOUDFLARE_COMPATIBILITY_DATE = __webpack_exports__.CLOUDFLARE_COMPATIBILITY_DATE;
 exports.CLOUDFLARE_WORKERS_TYPES_VERSION = __webpack_exports__.CLOUDFLARE_WORKERS_TYPES_VERSION;
-exports.CROSS_ENV_VERSION = __webpack_exports__.CROSS_ENV_VERSION;
-exports.DRIZZLE_ORM_VERSION = __webpack_exports__.DRIZZLE_ORM_VERSION;
 exports.EFFECT_TSGO_VERSION = __webpack_exports__.EFFECT_TSGO_VERSION;
 exports.EFFECT_VERSION = __webpack_exports__.EFFECT_VERSION;
-exports.EFFECT_VITEST_VERSION = __webpack_exports__.EFFECT_VITEST_VERSION;
 exports.I18NEXT_VERSION = __webpack_exports__.I18NEXT_VERSION;
 exports.LEFTHOOK_VERSION = __webpack_exports__.LEFTHOOK_VERSION;
 exports.MINIFLARE_VERSION = __webpack_exports__.MINIFLARE_VERSION;
+exports.MODULE_FEDERATION_MODERN_JS_V3_FORK_VERSION = __webpack_exports__.MODULE_FEDERATION_MODERN_JS_V3_FORK_VERSION;
 exports.MODULE_FEDERATION_NODE_VERSION = __webpack_exports__.MODULE_FEDERATION_NODE_VERSION;
 exports.MODULE_FEDERATION_VERSION = __webpack_exports__.MODULE_FEDERATION_VERSION;
-exports.MSGPACKR_VERSION = __webpack_exports__.MSGPACKR_VERSION;
 exports.NODE_FETCH_VERSION = __webpack_exports__.NODE_FETCH_VERSION;
 exports.NODE_VERSION = __webpack_exports__.NODE_VERSION;
 exports.OXFMT_VERSION = __webpack_exports__.OXFMT_VERSION;
@@ -135,25 +174,22 @@ exports.TYPES_NODE_VERSION = __webpack_exports__.TYPES_NODE_VERSION;
 exports.TYPES_REACT_DOM_VERSION = __webpack_exports__.TYPES_REACT_DOM_VERSION;
 exports.TYPES_REACT_VERSION = __webpack_exports__.TYPES_REACT_VERSION;
 exports.ULTRACITE_VERSION = __webpack_exports__.ULTRACITE_VERSION;
+exports.ULTRAMODERN_PACKAGE_PINS = __webpack_exports__.ULTRAMODERN_PACKAGE_PINS;
 exports.WORKERD_VERSION = __webpack_exports__.WORKERD_VERSION;
 exports.WRANGLER_VERSION = __webpack_exports__.WRANGLER_VERSION;
 exports.ZEPHYR_AGENT_VERSION = __webpack_exports__.ZEPHYR_AGENT_VERSION;
 exports.ZEPHYR_RSPACK_PLUGIN_VERSION = __webpack_exports__.ZEPHYR_RSPACK_PLUGIN_VERSION;
-exports.ZOD_VERSION = __webpack_exports__.ZOD_VERSION;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
     "CLOUDFLARE_COMPATIBILITY_DATE",
     "CLOUDFLARE_WORKERS_TYPES_VERSION",
-    "CROSS_ENV_VERSION",
-    "DRIZZLE_ORM_VERSION",
     "EFFECT_TSGO_VERSION",
     "EFFECT_VERSION",
-    "EFFECT_VITEST_VERSION",
     "I18NEXT_VERSION",
     "LEFTHOOK_VERSION",
     "MINIFLARE_VERSION",
+    "MODULE_FEDERATION_MODERN_JS_V3_FORK_VERSION",
     "MODULE_FEDERATION_NODE_VERSION",
     "MODULE_FEDERATION_VERSION",
-    "MSGPACKR_VERSION",
     "NODE_FETCH_VERSION",
     "NODE_VERSION",
     "OXFMT_VERSION",
@@ -173,11 +209,11 @@ for(var __rspack_i in __webpack_exports__)if (-1 === [
     "TYPES_REACT_DOM_VERSION",
     "TYPES_REACT_VERSION",
     "ULTRACITE_VERSION",
+    "ULTRAMODERN_PACKAGE_PINS",
     "WORKERD_VERSION",
     "WRANGLER_VERSION",
     "ZEPHYR_AGENT_VERSION",
-    "ZEPHYR_RSPACK_PLUGIN_VERSION",
-    "ZOD_VERSION"
+    "ZEPHYR_RSPACK_PLUGIN_VERSION"
 ].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
 Object.defineProperty(exports, '__esModule', {
     value: true