@bleedingdev/modern-js-create 3.5.0-ultramodern.0 → 3.5.0-ultramodern.10

package/dist/esm-node/ultramodern-tooling/commands.js

@@ -5,7 +5,9 @@ import node_os from "node:os";
 import node_path from "node:path";
 import { fileURLToPath } from "node:url";
 import { resolveCreatePackageRoot } from "../create-package-root.js";
+import { BLEEDINGDEV_PACKAGE_NAME_PREFIX, BLEEDINGDEV_PACKAGE_SCOPE, ULTRAMODERN_SINGLE_APP_MODERN_PACKAGES, ULTRAMODERN_WORKSPACE_MODERN_PACKAGES, WORKSPACE_PACKAGE_VERSION, modernPackageSpecifier } from "../ultramodern-package-source.js";
 import { validateModuleFederationTypes } from "../ultramodern-workspace/mf-validation.js";
+import { EFFECT_TSGO_VERSION, EFFECT_VERSION, EFFECT_VITEST_VERSION, OXFMT_VERSION, OXLINT_VERSION, TYPESCRIPT_NATIVE_PREVIEW_VERSION, WRANGLER_VERSION, ZEPHYR_AGENT_VERSION, ZEPHYR_RSPACK_PLUGIN_VERSION } from "../ultramodern-workspace/versions.js";
 import { createWorkspaceValidationScript } from "../ultramodern-workspace/workspace-scripts.js";
 import { readUltramodernConfig, workspaceAppsFromToolingConfig } from "./config.js";
 const commands_dirname = node_path.dirname(fileURLToPath(import.meta.url));
@@ -18,6 +20,7 @@ Commands:
   validate
   typecheck
   mf-types
+  migrate-strict-effect
   public-surface
   cloudflare-proof
   performance-readiness
@@ -83,6 +86,400 @@ Checks real Module Federation config files and DTS archives for exposed apps.
     });
     return 0;
 }
+const modernPackageNames = new Set([
+    ...ULTRAMODERN_SINGLE_APP_MODERN_PACKAGES,
+    ...ULTRAMODERN_WORKSPACE_MODERN_PACKAGES
+]);
+function readJsonFile(filePath) {
+    return JSON.parse(node_fs.readFileSync(filePath, 'utf-8'));
+}
+function writeJsonFile(filePath, value) {
+    node_fs.writeFileSync(filePath, `${JSON.stringify(value, null, 2)}\n`, 'utf-8');
+}
+function readOption(args, name) {
+    const prefix = `${name}=`;
+    const inline = args.find((arg)=>arg.startsWith(prefix));
+    if (inline) {
+        const value = inline.slice(prefix.length);
+        if (!value) throw new Error(`${name} needs a value.`);
+        return value;
+    }
+    const index = args.indexOf(name);
+    if (-1 === index) return;
+    const value = args[index + 1];
+    if (!value || value.startsWith('--')) throw new Error(`${name} needs a value.`);
+    return value;
+}
+function hasFlag(args, name) {
+    return args.includes(name);
+}
+function listWorkspacePackageFiles(workspaceRoot) {
+    const packageFiles = [
+        'package.json'
+    ];
+    for (const directory of [
+        'apps',
+        'verticals',
+        'packages'
+    ]){
+        const absoluteDirectory = node_path.join(workspaceRoot, directory);
+        if (node_fs.existsSync(absoluteDirectory)) for (const entry of node_fs.readdirSync(absoluteDirectory, {
+            withFileTypes: true
+        })){
+            if (!entry.isDirectory()) continue;
+            const packageFile = node_path.join(directory, entry.name, 'package.json');
+            if (node_fs.existsSync(node_path.join(workspaceRoot, packageFile))) packageFiles.push(packageFile);
+        }
+    }
+    return packageFiles;
+}
+function updateModernDependencies(packageJson, packageSource) {
+    let changed = false;
+    for (const section of [
+        'dependencies',
+        'devDependencies',
+        'peerDependencies',
+        'optionalDependencies'
+    ]){
+        const dependencies = packageJson[section];
+        if (!(!dependencies || 'object' != typeof dependencies || Array.isArray(dependencies))) for (const packageName of Object.keys(dependencies)){
+            if (!modernPackageNames.has(packageName)) continue;
+            const nextSpecifier = modernPackageSpecifier(packageName, packageSource);
+            if (dependencies[packageName] !== nextSpecifier) {
+                dependencies[packageName] = nextSpecifier;
+                changed = true;
+            }
+        }
+    }
+    return changed;
+}
+const generatedToolingDependencyPins = new Map([
+    [
+        '@effect/tsgo',
+        EFFECT_TSGO_VERSION
+    ],
+    [
+        "@typescript/native-preview",
+        TYPESCRIPT_NATIVE_PREVIEW_VERSION
+    ],
+    [
+        'oxfmt',
+        OXFMT_VERSION
+    ],
+    [
+        'oxlint',
+        OXLINT_VERSION
+    ],
+    [
+        'wrangler',
+        WRANGLER_VERSION
+    ],
+    [
+        'zephyr-agent',
+        ZEPHYR_AGENT_VERSION
+    ],
+    [
+        'zephyr-rspack-plugin',
+        ZEPHYR_RSPACK_PLUGIN_VERSION
+    ]
+]);
+const strictEffectPackageVersionPolicyExclusions = [
+    `effect@${EFFECT_VERSION}`,
+    `@effect/opentelemetry@${EFFECT_VERSION}`
+];
+function updateGeneratedToolingDependencies(packageJson) {
+    let changed = false;
+    for (const section of [
+        'dependencies',
+        'devDependencies',
+        'peerDependencies',
+        'optionalDependencies'
+    ]){
+        const dependencies = packageJson[section];
+        if (!(!dependencies || 'object' != typeof dependencies || Array.isArray(dependencies))) {
+            for (const [packageName, version] of generatedToolingDependencyPins)if (Object.prototype.hasOwnProperty.call(dependencies, packageName) && dependencies[packageName] !== version) {
+                dependencies[packageName] = version;
+                changed = true;
+            }
+        }
+    }
+    return changed;
+}
+const cloudflareModernDeployCommand = 'ULTRAMODERN_ZEPHYR=false MODERNJS_DEPLOY=cloudflare modern deploy';
+const cloudflareModernDeploySkipBuildCommand = `${cloudflareModernDeployCommand} --skip-build`;
+const cloudflareWranglerDeployCommand = 'wrangler deploy --config .output/wrangler.json';
+const cloudflareWranglerDeployInvalidSkipBuildCommand = `${cloudflareWranglerDeployCommand} --skip-build`;
+function updateGeneratedPackageScripts(packageJson) {
+    const scripts = packageJson.scripts;
+    if (!scripts || 'object' != typeof scripts || Array.isArray(scripts)) return false;
+    let changed = false;
+    const cloudflareBuild = scripts['cloudflare:build'];
+    if ('string' == typeof cloudflareBuild && cloudflareBuild.includes(cloudflareModernDeployCommand) && !cloudflareBuild.includes(cloudflareModernDeploySkipBuildCommand)) {
+        scripts['cloudflare:build'] = cloudflareBuild.replace(cloudflareModernDeployCommand, cloudflareModernDeploySkipBuildCommand);
+        changed = true;
+    }
+    const cloudflareDeploy = scripts['cloudflare:deploy'];
+    if ('string' == typeof cloudflareDeploy && cloudflareDeploy.includes(cloudflareWranglerDeployInvalidSkipBuildCommand)) {
+        scripts['cloudflare:deploy'] = cloudflareDeploy.replace(cloudflareWranglerDeployInvalidSkipBuildCommand, cloudflareWranglerDeployCommand);
+        changed = true;
+    }
+    return changed;
+}
+function normalizeStrictEffectApiMetadata(value) {
+    const api = value.api;
+    if (!api || 'object' != typeof api || Array.isArray(api)) return false;
+    let changed = false;
+    const oldEffect = api.effect;
+    if (oldEffect && 'object' == typeof oldEffect && !Array.isArray(oldEffect)) {
+        if (void 0 === api.stem && 'string' == typeof oldEffect.stem) {
+            api.stem = oldEffect.stem;
+            changed = true;
+        }
+        if (void 0 === api.prefix && 'string' == typeof oldEffect.prefix) {
+            api.prefix = oldEffect.prefix;
+            changed = true;
+        }
+        if (void 0 === api.consumedBy && Array.isArray(oldEffect.consumedBy)) {
+            api.consumedBy = oldEffect.consumedBy;
+            changed = true;
+        }
+        delete api.effect;
+        changed = true;
+    }
+    if (void 0 !== api.runtime && 'effect' !== api.runtime) {
+        api.runtime = 'effect';
+        changed = true;
+    }
+    if (api.bff && 'object' == typeof api.bff && !Array.isArray(api.bff)) {
+        if (true !== api.bff.strictEffectApproach) {
+            api.bff.strictEffectApproach = true;
+            changed = true;
+        }
+    }
+    if ('string' == typeof value.path) {
+        const directServerEntry = `${value.path}/api/index.ts`;
+        if ('string' == typeof api.serverEntry && /\/api\/effect\/index\.[cm]?[jt]sx?$/u.test(api.serverEntry)) {
+            api.serverEntry = directServerEntry;
+            changed = true;
+        }
+        if (api.contract && 'object' == typeof api.contract && !Array.isArray(api.contract)) {
+            if ('./shared/effect/api' === api.contract.export) {
+                api.contract.export = './api';
+                changed = true;
+            }
+            if ('string' == typeof api.contract.path && /\/shared\/effect\/api\.[cm]?[jt]sx?$/u.test(api.contract.path)) {
+                api.contract.path = `${value.path}/shared/api.ts`;
+                changed = true;
+            }
+        }
+        if (api.client && 'object' == typeof api.client && !Array.isArray(api.client)) {
+            if ('./effect/client' === api.client.export) {
+                api.client.export = './api/client';
+                changed = true;
+            }
+            if ('string' == typeof api.client.path && /\/src\/effect\/[^/]+-client\.[cm]?ts$/u.test(api.client.path)) {
+                const basename = node_path.basename(api.client.path);
+                api.client.path = `${value.path}/src/api/${basename}`;
+                changed = true;
+            }
+        }
+        if (void 0 === api.serverEntry && 'effect' === api.runtime) {
+            api.serverEntry = directServerEntry;
+            changed = true;
+        }
+    }
+    return changed;
+}
+function replaceYamlLine(source, pattern, replacement) {
+    const updated = source.replace(pattern, replacement);
+    return {
+        source: updated,
+        changed: updated !== source
+    };
+}
+function ensureYamlListItem(source, key, item) {
+    const itemLine = `  - '${item}'`;
+    const headerPattern = new RegExp(`^${key}:\\n(?:(?:  - .+\\n)*)`, 'mu');
+    const header = source.match(headerPattern);
+    if (header) {
+        if (header[0].split('\n').includes(itemLine)) return {
+            source,
+            changed: false
+        };
+        return {
+            source: source.replace(headerPattern, `${header[0]}${itemLine}\n`),
+            changed: true
+        };
+    }
+    const block = `${key}:\n${itemLine}\n`;
+    const afterTrustPolicyIgnore = source.replace(/^(trustPolicyIgnoreAfter: .+\n)/mu, `$1${block}`);
+    if (afterTrustPolicyIgnore !== source) return {
+        source: afterTrustPolicyIgnore,
+        changed: true
+    };
+    return {
+        source: `${source.trimEnd()}\n${block}`,
+        changed: true
+    };
+}
+function updateGeneratedPnpmWorkspacePolicy(workspaceRoot) {
+    const workspaceFile = node_path.join(workspaceRoot, 'pnpm-workspace.yaml');
+    if (!node_fs.existsSync(workspaceFile)) return false;
+    let source = node_fs.readFileSync(workspaceFile, 'utf-8');
+    let changed = false;
+    const replacements = [
+        [
+            /^ {4}'@effect\/vitest>effect': .+$/mu,
+            `    '@effect/vitest>effect': '${EFFECT_VERSION}'`
+        ],
+        [
+            /^ {2}'@effect\/vitest': .+$/mu,
+            `  '@effect/vitest': ${EFFECT_VITEST_VERSION}`
+        ],
+        [
+            /^ {2}effect: .+$/mu,
+            `  effect: ${EFFECT_VERSION}`
+        ]
+    ];
+    for (const [pattern, replacement] of replacements){
+        const result = replaceYamlLine(source, pattern, replacement);
+        source = result.source;
+        changed = result.changed || changed;
+    }
+    for (const item of strictEffectPackageVersionPolicyExclusions){
+        const packageName = item.slice(0, item.lastIndexOf('@'));
+        const escapedPackageName = packageName.replace(/[.*+?^${}()|[\]\\]/gu, '\\$&');
+        const currentVersion = replaceYamlLine(source, new RegExp(`^ {2}- '${escapedPackageName}@[^']+'$`, 'gmu'), `  - '${item}'`);
+        source = currentVersion.source;
+        changed = currentVersion.changed || changed;
+        for (const policyKey of [
+            'minimumReleaseAgeExclude',
+            'trustPolicyExclude'
+        ]){
+            const policyExclude = ensureYamlListItem(source, policyKey, item);
+            source = policyExclude.source;
+            changed = policyExclude.changed || changed;
+        }
+    }
+    if (changed) node_fs.writeFileSync(workspaceFile, source, 'utf-8');
+    return changed;
+}
+function updateUltramodernConfig(workspaceRoot, packageSource) {
+    const configPath = node_path.join(workspaceRoot, '.modernjs/ultramodern.json');
+    const config = readJsonFile(configPath);
+    config.packageSource = {
+        strategy: packageSource.strategy,
+        modernPackageVersion: packageSource.modernPackageVersion,
+        ...packageSource.registry ? {
+            registry: packageSource.registry
+        } : {},
+        ...packageSource.aliasScope ? {
+            aliasScope: packageSource.aliasScope
+        } : {},
+        ...packageSource.aliasPackageNamePrefix ? {
+            aliasPackageNamePrefix: packageSource.aliasPackageNamePrefix
+        } : {}
+    };
+    for (const app of config.topology?.apps ?? [])if (app && 'object' == typeof app && !Array.isArray(app)) normalizeStrictEffectApiMetadata(app);
+    writeJsonFile(configPath, config);
+}
+function updateReferenceTopology(workspaceRoot) {
+    const topologyPath = node_path.join(workspaceRoot, 'topology/reference-topology.json');
+    if (!node_fs.existsSync(topologyPath)) return false;
+    const topology = readJsonFile(topologyPath);
+    let changed = false;
+    for (const vertical of topology.verticals ?? [])if (vertical && 'object' == typeof vertical && !Array.isArray(vertical)) changed = normalizeStrictEffectApiMetadata(vertical) || changed;
+    if (changed) writeJsonFile(topologyPath, topology);
+    return changed;
+}
+function createMigrationPackageSource(args, current) {
+    const strategy = hasFlag(args, '--workspace') ? 'workspace' : 'install';
+    const registry = readOption(args, '--registry') ?? readOption(args, '--ultramodern-package-registry');
+    const explicitAliasScope = readOption(args, '--alias-scope') ?? readOption(args, '--ultramodern-package-scope');
+    const aliasScope = explicitAliasScope ?? ('install' === strategy && void 0 === registry ? current.packageSource?.aliasScope ?? BLEEDINGDEV_PACKAGE_SCOPE : current.packageSource?.aliasScope);
+    const aliasPackageNamePrefix = readOption(args, '--alias-package-name-prefix') ?? readOption(args, '--ultramodern-package-name-prefix') ?? current.packageSource?.aliasPackageNamePrefix ?? (aliasScope ? BLEEDINGDEV_PACKAGE_NAME_PREFIX : void 0);
+    if ('workspace' === strategy) return {
+        strategy,
+        modernPackageVersion: WORKSPACE_PACKAGE_VERSION,
+        ...registry ? {
+            registry
+        } : {},
+        ...aliasScope ? {
+            aliasScope
+        } : {},
+        ...aliasPackageNamePrefix ? {
+            aliasPackageNamePrefix
+        } : {}
+    };
+    const version = readOption(args, '--version') ?? readOption(args, '--ultramodern-package-version') ?? current.packageSource?.modernPackageVersion;
+    if (!version || version === WORKSPACE_PACKAGE_VERSION) throw new Error('migrate-strict-effect needs --version <published-ultramodern-version> for install package source.');
+    return {
+        strategy,
+        modernPackageVersion: version,
+        ...registry ? {
+            registry
+        } : {},
+        ...aliasScope ? {
+            aliasScope
+        } : {},
+        ...aliasPackageNamePrefix ? {
+            aliasPackageNamePrefix
+        } : {}
+    };
+}
+function runPnpmLockfileRefresh(context) {
+    const result = spawnSync('pnpm', [
+        'install',
+        '--lockfile-only',
+        "--ignore-scripts"
+    ], {
+        cwd: context.workspaceRoot,
+        stdio: 'inherit'
+    });
+    if (result.error) throw result.error;
+    return result.status ?? 1;
+}
+function runMigrateStrictEffect(args, context) {
+    if (args.includes('--help') || args.includes('-h')) {
+        process.stdout.write(`Usage:
+  modern-js-create ultramodern migrate-strict-effect --version <version> [--skip-install]
+
+Updates generated UltraModern package-source metadata, Modern package aliases,
+framework-owned toolchain pins, direct Effect API topology metadata, strict
+Effect pnpm overrides/trust policy, and the pnpm lockfile. Source code still
+has to pass pnpm api:check and pnpm contract:check.
+`);
+        return 0;
+    }
+    const current = readUltramodernConfig(context.workspaceRoot);
+    const packageSource = createMigrationPackageSource(args, current);
+    updateUltramodernConfig(context.workspaceRoot, packageSource);
+    updateReferenceTopology(context.workspaceRoot);
+    for (const relativePackageFile of listWorkspacePackageFiles(context.workspaceRoot)){
+        const packageFile = node_path.join(context.workspaceRoot, relativePackageFile);
+        const packageJson = readJsonFile(packageFile);
+        if ('package.json' === relativePackageFile) {
+            packageJson.modernjs ??= {};
+            packageJson.modernjs.packageSource = {
+                strategy: packageSource.strategy,
+                config: './.modernjs/ultramodern.json'
+            };
+        }
+        const modernDependenciesChanged = updateModernDependencies(packageJson, packageSource);
+        const toolingDependenciesChanged = updateGeneratedToolingDependencies(packageJson);
+        const generatedScriptsChanged = updateGeneratedPackageScripts(packageJson);
+        const changed = modernDependenciesChanged || toolingDependenciesChanged || generatedScriptsChanged;
+        if (changed) writeJsonFile(packageFile, packageJson);
+        else if ('package.json' === relativePackageFile) writeJsonFile(packageFile, packageJson);
+    }
+    updateGeneratedPnpmWorkspacePolicy(context.workspaceRoot);
+    if (!hasFlag(args, '--skip-install')) {
+        const status = runPnpmLockfileRefresh(context);
+        if (0 !== status) return status;
+    }
+    process.stdout.write(`UltraModern strict Effect metadata migrated to ${packageSource.modernPackageVersion}. Run pnpm api:check && pnpm contract:check next.\n`);
+    return 0;
+}
 function runSkills(args, context) {
     const [subcommand, ...rest] = args;
     if ('install' === subcommand) return spawnNodeScript("template-workspace/scripts/bootstrap-agent-skills.mjs", rest, context);
@@ -113,6 +510,8 @@ async function runUltramodernToolingCli(args, workspaceRoot = process.env.ULTRAM
                 });
             case 'mf-types':
                 return runMfTypes(rest, context);
+            case 'migrate-strict-effect':
+                return runMigrateStrictEffect(rest, context);
             case 'public-surface':
                 return spawnNodeScript("templates/workspace-scripts/generate-public-surface-assets.mjs", rest, context);
             case 'cloudflare-proof':

package/dist/esm-node/ultramodern-workspace/contracts.js

@@ -255,6 +255,7 @@ function createUltramodernConfig(scope, modernVersion, packageSource, apps = [
                 publicSurface: "scripts/generate-public-surface-assets.mts",
                 cloudflareProof: "scripts/proof-cloudflare-version.mts",
                 performanceReadiness: "scripts/ultramodern-performance-readiness.mts",
+                migrateStrictEffect: "scripts/migrate-strict-effect.mts",
                 apiBoundaries: "scripts/check-ultramodern-api-boundaries.mts",
                 skills: "scripts/bootstrap-agent-skills.mts"
             }

package/dist/esm-node/ultramodern-workspace/module-federation.js

@@ -94,6 +94,8 @@ ${defaultAssetPrefixSource}
 // load remoteEntry.js and exposed chunks from the remote origin, not the host.
 const assetPrefix =
   configuredModernAssetPrefix || configuredUltramodernAssetPrefix || defaultAssetPrefix;
+const buildCacheTarget = cloudflareDeployEnabled ? 'cloudflare' : 'web';
+const buildCacheDirectory = \`node_modules/.cache/rspack-\${appId}-\${buildCacheTarget}\`;
 
 if (
   cloudflareDeployEnabled &&
@@ -140,6 +142,10 @@ ${bffConfig}      ...(cloudflareDeployEnabled
         splitRouteChunks: true,
       },
       performance: {
+        buildCache: {
+          cacheDigest: [appId, buildCacheTarget],
+          cacheDirectory: buildCacheDirectory,
+        },
         rsdoctor: {
           disableClientServer: true,
           enabled: process.env['ULTRAMODERN_RSDOCTOR'] === 'true',

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

@@ -179,6 +179,7 @@ function createRootPackageJson(scope, packageSource, remotes = [], bridge) {
             '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",
@@ -371,7 +372,7 @@ function createAppPackage(scope, app, packageSource, enableTailwind, remotes = [
         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:build': `ULTRAMODERN_ZEPHYR=false MODERNJS_DEPLOY=cloudflare modern build && ${publicSurfaceCloudflareBuildCommand} && ULTRAMODERN_ZEPHYR=false MODERNJS_DEPLOY=cloudflare modern deploy --skip-build && ${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}`,

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

@@ -9,12 +9,14 @@ const CLOUDFLARE_COMPATIBILITY_DATE = '2026-06-02';
 const TAILWIND_VERSION = '4.3.1';
 const TAILWIND_POSTCSS_VERSION = '4.3.1';
 const POSTCSS_VERSION = '8.5.15';
+const EFFECT_VERSION = '4.0.0-beta.91';
+const EFFECT_VITEST_VERSION = '4.0.0-beta.91';
 const EFFECT_TSGO_VERSION = '0.14.6';
 const TYPESCRIPT_STABLE_VERSION = '6.0.3';
-const TYPESCRIPT_NATIVE_PREVIEW_VERSION = '7.0.0-dev.20260624.1';
+const TYPESCRIPT_NATIVE_PREVIEW_VERSION = '7.0.0-dev.20260628.1';
 const TYPESCRIPT_VERSION = TYPESCRIPT_STABLE_VERSION;
 const OXLINT_VERSION = '1.71.0';
-const OXFMT_VERSION = '0.55.0';
+const OXFMT_VERSION = '0.56.0';
 const ULTRACITE_VERSION = '7.8.3';
 const LEFTHOOK_VERSION = '^2.1.9';
 const I18NEXT_VERSION = '26.3.1';
@@ -32,7 +34,9 @@ const ultramodernWorkspaceVersions = {
     tanstackRouter: TANSTACK_ROUTER_VERSION,
     tanstackRouterCore: TANSTACK_ROUTER_CORE_VERSION,
     moduleFederation: MODULE_FEDERATION_VERSION,
+    effect: EFFECT_VERSION,
+    effectVitest: EFFECT_VITEST_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_VERSION, REACT_VERSION, RSTACK_AGENT_SKILLS_COMMIT, TAILWIND_POSTCSS_VERSION, TAILWIND_VERSION, TANSTACK_ROUTER_CORE_VERSION, TANSTACK_ROUTER_VERSION, TYPESCRIPT_NATIVE_PREVIEW_VERSION, TYPESCRIPT_STABLE_VERSION, TYPESCRIPT_VERSION, TYPES_REACT_DOM_VERSION, TYPES_REACT_VERSION, ULTRACITE_VERSION, WRANGLER_VERSION, ZEPHYR_AGENT_VERSION, ZEPHYR_RSPACK_PLUGIN_VERSION, ultramodernWorkspaceVersions };
+export { CLOUDFLARE_COMPATIBILITY_DATE, EFFECT_TSGO_VERSION, EFFECT_VERSION, EFFECT_VITEST_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_VERSION, REACT_VERSION, RSTACK_AGENT_SKILLS_COMMIT, TAILWIND_POSTCSS_VERSION, TAILWIND_VERSION, TANSTACK_ROUTER_CORE_VERSION, TANSTACK_ROUTER_VERSION, TYPESCRIPT_NATIVE_PREVIEW_VERSION, TYPESCRIPT_STABLE_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-node/ultramodern-workspace/workspace-scripts.js

@@ -163,6 +163,7 @@ function writeGeneratedWorkspaceScripts(targetDir, _scope, _enableTailwind, _rem
     writeWorkspaceOwnedMtsScript(targetDir, 'proof-cloudflare-version', createToolWrapperScript('cloudflare-proof'));
     writeFileReplacing(targetDir, "scripts/ultramodern-performance-readiness.config.mjs", createPerformanceReadinessConfigScript());
     writeWorkspaceOwnedMtsScript(targetDir, 'ultramodern-performance-readiness', createToolWrapperScript('performance-readiness'));
+    writeWorkspaceOwnedMtsScript(targetDir, 'migrate-strict-effect', createToolWrapperScript('migrate-strict-effect'));
     writeWorkspaceOwnedMtsScript(targetDir, 'ultramodern-typecheck', createToolWrapperScript('typecheck'));
     writeWorkspaceOwnedMtsScript(targetDir, 'bootstrap-agent-skills', createSkillsToolWrapperScript());
     migrateCopiedWorkspaceScriptToMts(targetDir, 'setup-agent-reference-repos');

package/dist/esm-node/ultramodern-workspace/write-workspace.js

@@ -15,7 +15,7 @@ import { runCodeSmithOverlays } from "./overlays.js";
 import { createAppMfTypesTsConfig, createAppPackage, createAppTsConfig, createRootPackageJson, createRootTsConfig, createSharedContractsIndex, createSharedPackage, createSharedPackageTsConfig, createTsConfigBase } from "./package-json.js";
 import { resolvePackageSource } from "./package-source.js";
 import { createPublicWebAppArtifacts } from "./public-surface.js";
-import { NODE_FETCH_VERSION, NODE_VERSION, PNPM_VERSION, TANSTACK_ROUTER_CORE_VERSION, TANSTACK_ROUTER_VERSION, TYPESCRIPT_VERSION } from "./versions.js";
+import { EFFECT_VERSION, EFFECT_VITEST_VERSION, NODE_FETCH_VERSION, NODE_VERSION, PNPM_VERSION, TANSTACK_ROUTER_CORE_VERSION, TANSTACK_ROUTER_VERSION, TYPESCRIPT_VERSION } from "./versions.js";
 import { writeGeneratedWorkspaceScripts } from "./workspace-scripts.js";
 function writeApp(targetDir, scope, app, packageSource, enableTailwind, remotes = [], bridge) {
     const resolvedApp = 'shell' === app.kind ? createShellHost(remotes) : app;
@@ -131,6 +131,8 @@ function generateUltramodernWorkspace(options) {
         nodeVersion: NODE_VERSION,
         pnpmVersion: PNPM_VERSION,
         nodeFetchVersion: NODE_FETCH_VERSION,
+        effectVersion: EFFECT_VERSION,
+        effectVitestVersion: EFFECT_VITEST_VERSION,
         tanstackRouterCoreVersion: TANSTACK_ROUTER_CORE_VERSION,
         tanstackRouterVersion: TANSTACK_ROUTER_VERSION,
         typescriptVersion: TYPESCRIPT_VERSION,

package/dist/types/ultramodern-workspace/versions.d.ts

@@ -13,12 +13,14 @@ export declare const CLOUDFLARE_COMPATIBILITY_DATE = "2026-06-02";
 export declare const TAILWIND_VERSION = "4.3.1";
 export declare const TAILWIND_POSTCSS_VERSION = "4.3.1";
 export declare const POSTCSS_VERSION = "8.5.15";
+export declare const EFFECT_VERSION = "4.0.0-beta.91";
+export declare const EFFECT_VITEST_VERSION = "4.0.0-beta.91";
 export declare const EFFECT_TSGO_VERSION = "0.14.6";
 export declare const TYPESCRIPT_STABLE_VERSION = "6.0.3";
-export declare const TYPESCRIPT_NATIVE_PREVIEW_VERSION = "7.0.0-dev.20260624.1";
+export declare const TYPESCRIPT_NATIVE_PREVIEW_VERSION = "7.0.0-dev.20260628.1";
 export declare const TYPESCRIPT_VERSION = "6.0.3";
 export declare const OXLINT_VERSION = "1.71.0";
-export declare const OXFMT_VERSION = "0.55.0";
+export declare const OXFMT_VERSION = "0.56.0";
 export declare const ULTRACITE_VERSION = "7.8.3";
 export declare const LEFTHOOK_VERSION = "^2.1.9";
 export declare const I18NEXT_VERSION = "26.3.1";
@@ -36,6 +38,8 @@ export declare const ultramodernWorkspaceVersions: {
     tanstackRouter: string;
     tanstackRouterCore: string;
     moduleFederation: string;
+    effect: string;
+    effectVitest: string;
     tailwind: string;
     tailwindPostcss: string;
 };

package/package.json

@@ -21,7 +21,7 @@
   "engines": {
     "node": ">=20"
   },
-  "version": "3.5.0-ultramodern.0",
+  "version": "3.5.0-ultramodern.10",
   "types": "./dist/types/index.d.ts",
   "main": "./dist/esm-node/index.js",
   "bin": {
@@ -75,14 +75,14 @@
   ],
   "dependencies": {
     "@modern-js/codesmith": "2.6.9",
-    "oxfmt": "0.55.0",
+    "oxfmt": "0.56.0",
     "ultracite": "7.8.3",
-    "@modern-js/i18n-utils": "npm:@bleedingdev/modern-js-i18n-utils@3.5.0-ultramodern.0"
+    "@modern-js/i18n-utils": "npm:@bleedingdev/modern-js-i18n-utils@3.5.0-ultramodern.10"
   },
   "devDependencies": {
-    "@rslib/core": "0.23.0",
+    "@rslib/core": "0.23.1",
     "@types/node": "^26.0.1",
-    "@typescript/native-preview": "7.0.0-dev.20260624.1",
+    "@typescript/native-preview": "7.0.0-dev.20260628.1",
     "tsx": "^4.22.4",
     "typescript": "^6.0.3",
     "@scripts/rstest-config": "2.66.0"
@@ -99,6 +99,6 @@
     "test": "rm -rf dist && rslib build -c rslibconfig.mts && rstest --passWithNoTests"
   },
   "ultramodern": {
-    "frameworkVersion": "3.5.0-ultramodern.0"
+    "frameworkVersion": "3.5.0-ultramodern.10"
   }
 }

package/template-workspace/README.md.handlebars

@@ -69,7 +69,7 @@ typecheck, skills, i18n boundary validation, contract validation, and build as
 separate matrix jobs so failures are isolated and parallelizable.
 
 Type checking is TS7-first. `pnpm typecheck` runs
-`scripts/ultramodern-typecheck.mjs` in TS-Go build mode over
+`scripts/ultramodern-typecheck.mts` in TS-Go build mode over
 `tsconfig.json` project references, with native-preview `--checkers` and
 `--builders` enabled by default. `@typescript/native-preview` is the TS7 latest
 dev compiler lane. The classic `typescript` package is pinned to latest TS6
@@ -147,11 +147,54 @@ ULTRAMODERN_PUBLIC_URL_SHELL_SUPER_APP=https://shell-super-app.example.workers.d
 pnpm cloudflare:proof -- --require-public-urls
 ```
 
+## Strict Effect API
+
+Generated HTTP APIs use the direct strict Effect topology only:
+
+- API contracts live at `shared/api.ts`.
+- Runtime entries live at `api/index.ts`.
+- Browser clients live under `src/api/*-client.ts`.
+- `modern.config.ts` uses `bff.runtimeFramework: 'effect'`,
+  `bff.effect.entry: './api/index'`, and
+  `bff.effect.strictEffectApproach: true`.
+
+Do not add `api/effect`, `api/lambda`, `shared/effect`, `src/effect`, Hono
+server imports, raw request handlers, manual `request.json()` parsing, or
+manual `new Response(...)` construction inside generated API modules.
+`pnpm api:check` and Oxlint enforce this. Model requests, responses, and typed
+errors with concrete Effect `Schema` values; generic JSON shortcuts such as
+`Schema.UnknownFromJsonString`, `Schema.Unknown`, and `Schema.Any` are rejected
+in API modules.
+
+Generated pnpm overrides pin the framework-compatible Effect cohort. Keep
+`effect` and `@effect/vitest` aligned with `pnpm-workspace.yaml`; do not add
+new direct package-level Effect versions unless the whole UltraModern cohort is
+upgraded. The generated pnpm policy intentionally excludes the matching
+`effect` and `@effect/opentelemetry` cohort versions from the
+minimum-release-age and no-downgrade checks while Effect's beta publishes move
+from trusted-publisher metadata to provenance attestations.
+
+For older generated workspaces, run the framework migration command first:
+
+```bash
+pnpm dlx @bleedingdev/modern-js-create@3.5.0-ultramodern.10 ultramodern \
+  migrate-strict-effect --version 3.5.0-ultramodern.10
+pnpm api:check
+pnpm contract:check
+```
+
+The command updates generated package-source metadata, Modern package aliases,
+framework-owned toolchain pins, direct API topology metadata, strict Effect pnpm
+overrides/trust policy, and the lockfile. Remaining failures are source
+migration work; fix the owning API files instead of adding compatibility shims.
+
 ## Troubleshooting
 
 | Symptom | Current check | Owner |
 | --- | --- | --- |
 | Package cohort mismatch | Regenerate with one package source strategy, run `mise install`, then rerun `pnpm install` from the activated shell. | Generated workspace package source metadata |
+| Effect runtime cohort mismatch | Keep `effect` and `@effect/vitest` on the generated pnpm override versions, then rerun `pnpm install`. | Generated workspace dependency policy |
+| Old nested API path | Run `pnpm api:check`, move code to `api/index.ts`, `shared/api.ts`, and `src/api/*`, then delete `api/effect`, `api/lambda`, `shared/effect`, and `src/effect`. | API owner |
 | Install failure | Check the active Node/pnpm from `mise install`; rerun `pnpm install` after the shell sees the pinned versions. | Toolchain setup |
 | Build failure | Run the matching primitive gate (`pnpm lint`, `pnpm typecheck`, `pnpm i18n:boundaries`, `pnpm contract:check`) before `pnpm build`; fix the owning failure first. | Owning package or generated contract |
 | Missing public URL | Set the app public URL env key recorded in `.modernjs/ultramodern.json`, for example `ULTRAMODERN_PUBLIC_URL_SHELL_SUPER_APP`. | Deployment operator |