@bleedingdev/modern-js-app-tools 3.5.0-ultramodern.6 → 3.5.0-ultramodern.76

package/dist/esm-node/plugins/deploy/platforms/cloudflare-output-verifier/index.mjs

@@ -0,0 +1,134 @@
+import "node:module";
+import promises from "node:fs/promises";
+import node_path from "node:path";
+import { createCloudflareOutputPlan } from "../cloudflare-output-plan.mjs";
+import { verifyDeliveryUnitIdentity } from "./identity.mjs";
+import { addIssue, assertEqual, assertFlag } from "./issues.mjs";
+import { verifyManifestShape } from "./manifest.mjs";
+import { getEffectBffWorker, getWorkerBundleReferences, missingWorkerBundleMessage, resolveWorkerBundleReference, verifyWorkerBundleReferences, verifyWorkerImport } from "./worker-bundles.mjs";
+const pathExists = async (filePath)=>{
+    try {
+        await promises.access(filePath);
+        return true;
+    } catch  {
+        return false;
+    }
+};
+const readJson = async (filePath)=>JSON.parse(await promises.readFile(filePath, 'utf-8'));
+const verifyCloudflareOutput = async (options)=>{
+    const outputDirectory = node_path.resolve(options.outputDirectory);
+    const issues = [];
+    const outputPlan = createCloudflareOutputPlan(outputDirectory);
+    for (const relativePath of outputPlan.requiredFiles){
+        const filePath = node_path.join(outputDirectory, relativePath);
+        if (!await pathExists(filePath)) addIssue(issues, {
+            code: 'missing-file',
+            message: `Cloudflare output is missing ${relativePath}.`,
+            path: filePath
+        });
+    }
+    const manifestPath = outputPlan.paths.workerManifest;
+    const wranglerPath = outputPlan.paths.wranglerConfig;
+    const packagePath = outputPlan.paths.outputPackage;
+    const workerPackagePath = outputPlan.paths.workerPackage;
+    const manifest = await pathExists(manifestPath) ? await readJson(manifestPath) : void 0;
+    const wrangler = await pathExists(wranglerPath) ? await readJson(wranglerPath) : void 0;
+    const outputPackage = await pathExists(packagePath) ? await readJson(packagePath) : void 0;
+    const workerPackage = await pathExists(workerPackagePath) ? await readJson(workerPackagePath) : void 0;
+    if (manifest) {
+        verifyManifestShape(issues, manifest, manifestPath);
+        verifyDeliveryUnitIdentity(issues, manifest, manifestPath, options.deliveryUnit);
+        const workerReferences = getWorkerBundleReferences(manifest);
+        const providedWorkerPackages = new Set(workerPackage?.dependencies && 'object' == typeof workerPackage.dependencies ? Object.keys(workerPackage.dependencies) : []);
+        if (workerReferences.length > 0 && !await pathExists(workerPackagePath)) addIssue(issues, {
+            code: 'missing-file',
+            message: 'Cloudflare output is missing worker/package.json for referenced worker bundles.',
+            path: workerPackagePath
+        });
+        if (manifest.bff?.runtimeFramework === 'effect' && !getEffectBffWorker(manifest)) addIssue(issues, {
+            code: 'missing-worker-bundle',
+            message: 'Cloudflare Effect BFF manifest points to a missing worker bundle.'
+        });
+        for (const workerReference of workerReferences){
+            const resolvedWorker = resolveWorkerBundleReference(issues, outputDirectory, workerReference, manifestPath);
+            if (!resolvedWorker) continue;
+            const workerExists = await pathExists(resolvedWorker.path);
+            if (!workerExists) addIssue(issues, {
+                code: 'missing-worker-bundle',
+                message: missingWorkerBundleMessage(workerReference),
+                path: resolvedWorker.path
+            });
+            if (workerExists) {
+                const workerSource = await promises.readFile(resolvedWorker.path, 'utf-8');
+                await verifyWorkerBundleReferences(issues, resolvedWorker, workerSource, {
+                    providedPackages: providedWorkerPackages,
+                    workerRoot: outputPlan.paths.workerBundle
+                });
+                if ('effect-bff' === resolvedWorker.kind && (workerSource.includes(';entityKind;') || workerSource.includes(';entityKind,entityKind;'))) addIssue(issues, {
+                    code: 'invalid-worker-bundle',
+                    message: 'Cloudflare Effect BFF worker bundle contains invalid Drizzle entityKind marker references.',
+                    path: resolvedWorker.path
+                });
+            }
+        }
+    }
+    if (wrangler) {
+        assertEqual(issues, wrangler.main, outputPlan.wrangler.main, {
+            code: 'invalid-wrangler',
+            message: `wrangler.json main must be ${outputPlan.wrangler.main}.`,
+            path: wranglerPath
+        });
+        assertEqual(issues, wrangler.assets?.binding, outputPlan.wrangler.assets.binding, {
+            code: 'invalid-wrangler',
+            message: 'wrangler.json assets.binding must be ASSETS.',
+            path: wranglerPath
+        });
+        assertEqual(issues, wrangler.assets?.directory, outputPlan.wrangler.assets.directory, {
+            code: 'invalid-wrangler',
+            message: 'wrangler.json assets.directory must be ./public.',
+            path: wranglerPath
+        });
+        assertEqual(issues, wrangler.assets?.run_worker_first, outputPlan.wrangler.assets.run_worker_first, {
+            code: 'invalid-wrangler',
+            message: 'wrangler.json assets.run_worker_first must be true.',
+            path: wranglerPath
+        });
+        for (const flag of outputPlan.wrangler.requiredCompatibilityFlags)assertFlag(issues, wrangler.compatibility_flags, flag, {
+            code: 'invalid-wrangler',
+            message: `wrangler.json compatibility_flags must include ${flag}.`,
+            path: wranglerPath
+        });
+    }
+    if (outputPackage) assertEqual(issues, outputPackage.type, outputPlan.packages.output.type, {
+        code: 'invalid-package',
+        message: '.output/package.json must declare type module.',
+        path: packagePath
+    });
+    if (workerPackage) assertEqual(issues, workerPackage.type, outputPlan.packages.worker.type, {
+        code: 'invalid-package',
+        message: '.output/worker/package.json must declare type commonjs.',
+        path: workerPackagePath
+    });
+    for (const leakedPath of outputPlan.publicLeakDirectories){
+        const publicPath = node_path.join(outputPlan.paths.publicAssets, leakedPath);
+        if (await pathExists(publicPath)) addIssue(issues, {
+            code: 'public-output-leak',
+            message: `Framework-owned ${leakedPath} output leaked into public assets.`,
+            path: publicPath
+        });
+    }
+    if (false !== options.importWorker && await pathExists(outputPlan.paths.workerEntry)) await verifyWorkerImport(issues, outputPlan.paths.workerEntry);
+    return {
+        ok: 0 === issues.length,
+        issues
+    };
+};
+const assertCloudflareOutput = async (options)=>{
+    const result = await verifyCloudflareOutput(options);
+    if (!result.ok) throw new Error([
+        'Cloudflare output verification failed:',
+        ...result.issues.map((issue)=>`- ${issue.code}: ${issue.message}${issue.path ? ` (${issue.path})` : ''}`)
+    ].join('\n'));
+};
+export { verifyCloudflareOutputMutationPolicy } from "./mutation-policy.mjs";
+export { assertCloudflareOutput, verifyCloudflareOutput };

package/dist/esm-node/plugins/deploy/platforms/cloudflare-output-verifier/issues.mjs

@@ -0,0 +1,11 @@
+import "node:module";
+const addIssue = (issues, issue)=>{
+    issues.push(issue);
+};
+const assertEqual = (issues, actual, expected, issue)=>{
+    if (actual !== expected) addIssue(issues, issue);
+};
+const assertFlag = (issues, flags, flag, issue)=>{
+    if (!Array.isArray(flags) || !flags.includes(flag)) addIssue(issues, issue);
+};
+export { addIssue, assertEqual, assertFlag };

package/dist/esm-node/plugins/deploy/platforms/cloudflare-output-verifier/manifest.mjs

@@ -0,0 +1,52 @@
+import "node:module";
+import { BFF_EFFECT_WORKER_DISPATCHER_EXPORT } from "../cloudflare/constants.mjs";
+import { CLOUDFLARE_ASSETS_BINDING, CLOUDFLARE_PUBLIC_ASSETS_DIRECTORY, CLOUDFLARE_RUNTIME_TYPE, CLOUDFLARE_WORKER_ENTRY } from "../cloudflare-output-contract.mjs";
+import { addIssue, assertEqual } from "./issues.mjs";
+const verifyManifestShape = (issues, manifest, manifestPath)=>{
+    assertEqual(issues, manifest.runtime?.type, CLOUDFLARE_RUNTIME_TYPE, {
+        code: 'invalid-manifest',
+        message: 'Cloudflare output manifest runtime.type must be cloudflare-module-worker.',
+        path: manifestPath
+    });
+    assertEqual(issues, manifest.runtime?.entry, CLOUDFLARE_WORKER_ENTRY, {
+        code: 'invalid-manifest',
+        message: `Cloudflare output manifest runtime.entry must be ${CLOUDFLARE_WORKER_ENTRY}.`,
+        path: manifestPath
+    });
+    assertEqual(issues, manifest.runtime?.fetchExport, true, {
+        code: 'invalid-manifest',
+        message: 'Cloudflare output manifest runtime.fetchExport must be true.',
+        path: manifestPath
+    });
+    assertEqual(issues, manifest.runtime?.nodeListen, false, {
+        code: 'invalid-manifest',
+        message: 'Cloudflare output manifest runtime.nodeListen must be false.',
+        path: manifestPath
+    });
+    assertEqual(issues, manifest.assets?.binding, CLOUDFLARE_ASSETS_BINDING, {
+        code: 'invalid-manifest',
+        message: 'Cloudflare output manifest assets.binding must be ASSETS.',
+        path: manifestPath
+    });
+    assertEqual(issues, manifest.assets?.directory, `./${CLOUDFLARE_PUBLIC_ASSETS_DIRECTORY}`, {
+        code: 'invalid-manifest',
+        message: 'Cloudflare output manifest assets.directory must be ./public.',
+        path: manifestPath
+    });
+    assertEqual(issues, manifest.assets?.runWorkerFirst, true, {
+        code: 'invalid-manifest',
+        message: 'Cloudflare output manifest assets.runWorkerFirst must be true.',
+        path: manifestPath
+    });
+    if (!Array.isArray(manifest.routeSpec?.routes)) addIssue(issues, {
+        code: 'invalid-manifest',
+        message: 'Cloudflare output manifest routeSpec.routes must be array.',
+        path: manifestPath
+    });
+    if (manifest.bff?.runtimeFramework === 'effect') assertEqual(issues, manifest.bff.dispatcherExport, BFF_EFFECT_WORKER_DISPATCHER_EXPORT, {
+        code: 'invalid-manifest',
+        message: `Cloudflare Effect BFF manifest dispatcherExport must be ${BFF_EFFECT_WORKER_DISPATCHER_EXPORT}.`,
+        path: manifestPath
+    });
+};
+export { verifyManifestShape };

package/dist/esm-node/plugins/deploy/platforms/cloudflare-output-verifier/mutation-policy.mjs

@@ -0,0 +1,100 @@
+import "node:module";
+import promises from "node:fs/promises";
+import node_path from "node:path";
+import { addIssue } from "./issues.mjs";
+const SOURCE_SCAN_FILE_PATTERN = /\.(?:[cm]?[jt]s|json)$/u;
+const SOURCE_SCAN_IGNORED_DIRECTORY_NAMES = new Set([
+    '.codex',
+    '.fastcontext',
+    '.git',
+    '.mf',
+    '.modernjs',
+    '.output',
+    'coverage',
+    'dist',
+    'dist-cloudflare',
+    'node_modules',
+    'repos',
+    'topology'
+]);
+const FORBIDDEN_MUTATION_PATTERNS = [
+    {
+        code: 'forbidden-mutation-pattern',
+        message: "Generated Cloudflare server worker output must not be rewritten by app scripts.",
+        pattern: /\.output\/server\/index\.mjs/u
+    },
+    {
+        code: 'forbidden-mutation-pattern',
+        message: "Generated Cloudflare server worker output must not be rewritten by app scripts.",
+        pattern: /path\.(?:join|resolve)\(\s*['"`]\.output['"`]\s*,\s*['"`]server['"`]\s*,\s*['"`]index\.mjs['"`]\s*\)/u
+    },
+    {
+        code: 'forbidden-mutation-pattern',
+        message: "Generated Cloudflare BFF worker bundles must not be rewritten by app scripts.",
+        pattern: /\.output\/worker\/[^'"`]*\.(?:mjs|cjs|js)/u
+    },
+    {
+        code: 'forbidden-mutation-pattern',
+        message: "Generated Cloudflare BFF worker bundles must not be rewritten by app scripts.",
+        pattern: /path\.(?:join|resolve)\(\s*['"`]\.output['"`]\s*,\s*['"`]worker['"`]\s*,\s*['"`][^'"`]+\.(?:mjs|cjs|js)['"`]\s*\)/u
+    },
+    {
+        code: 'forbidden-mutation-pattern',
+        message: "Drizzle entityKind worker bundle markers must be fixed in the framework toolchain, not post-build scripts.",
+        pattern: /replaceAll\(\s*['"`];entityKind(?:,entityKind)?;/u
+    },
+    {
+        code: 'forbidden-mutation-pattern',
+        message: "Effect BFF Cloudflare dispatch must not depend on duck-typed runtime helper probing in app scripts.",
+        pattern: /(?:typeof\s+[^;\n]*dispatchEffectBffRequest|['"`]dispatchEffectBffRequest['"`]\s+in\s+|\.dispatchEffectBffRequest\b)/u
+    },
+    {
+        code: 'forbidden-mutation-pattern',
+        message: "Effect BFF Cloudflare dispatch must not branch on handler.length in app scripts.",
+        pattern: /\bhandler\s*\.\s*length\b/u
+    }
+];
+const pathExists = async (filePath)=>{
+    try {
+        await promises.access(filePath);
+        return true;
+    } catch  {
+        return false;
+    }
+};
+const walkFiles = async (root)=>{
+    if (!await pathExists(root)) return [];
+    const entries = await promises.readdir(root, {
+        withFileTypes: true
+    });
+    const files = [];
+    for (const entry of entries){
+        if (SOURCE_SCAN_IGNORED_DIRECTORY_NAMES.has(entry.name)) continue;
+        const entryPath = node_path.join(root, entry.name);
+        if (entry.isDirectory()) {
+            files.push(...await walkFiles(entryPath));
+            continue;
+        }
+        if (SOURCE_SCAN_FILE_PATTERN.test(entry.name)) files.push(entryPath);
+    }
+    return files;
+};
+const verifyCloudflareOutputMutationPolicy = async (options)=>{
+    const issues = [];
+    const excludedFiles = new Set((options.excludePaths ?? []).map((entry)=>node_path.resolve(entry)));
+    const files = (await Promise.all(options.scanRoots.map((scanRoot)=>walkFiles(node_path.resolve(scanRoot))))).flat();
+    for (const file of files){
+        if (excludedFiles.has(file)) continue;
+        const source = await promises.readFile(file, 'utf-8');
+        for (const forbidden of FORBIDDEN_MUTATION_PATTERNS)if (forbidden.pattern.test(source)) addIssue(issues, {
+            code: forbidden.code,
+            message: forbidden.message,
+            path: file
+        });
+    }
+    return {
+        ok: 0 === issues.length,
+        issues
+    };
+};
+export { verifyCloudflareOutputMutationPolicy, walkFiles };

package/dist/esm-node/plugins/deploy/platforms/cloudflare-output-verifier/worker-bundles.mjs

@@ -0,0 +1,239 @@
+import "node:module";
+import promises from "node:fs/promises";
+import node_path from "node:path";
+import { pathToFileURL } from "node:url";
+import { parse } from "@babel/parser";
+import { CLOUDFLARE_WORKER_BUNDLE_DIRECTORY, CLOUDFLARE_WORKER_NODE_BUILTINS } from "../cloudflare-output-contract.mjs";
+import { addIssue } from "./issues.mjs";
+const getReferencedRouteWorkers = (manifest)=>Array.isArray(manifest?.routeSpec?.routes) ? manifest.routeSpec.routes.map((route)=>'string' == typeof route?.worker && route.worker.length > 0 ? route.worker : void 0).filter((worker)=>'string' == typeof worker) : [];
+const getEffectBffWorker = (manifest)=>manifest?.bff?.runtimeFramework === 'effect' && 'string' == typeof manifest.bff.worker ? manifest.bff.worker : void 0;
+const getWorkerBundleReferences = (manifest)=>{
+    const effectBffWorker = getEffectBffWorker(manifest);
+    return [
+        ...effectBffWorker ? [
+            {
+                dispatcherExport: 'string' == typeof manifest.bff?.dispatcherExport ? manifest.bff.dispatcherExport : void 0,
+                kind: 'effect-bff',
+                reference: effectBffWorker
+            }
+        ] : [],
+        ...getReferencedRouteWorkers(manifest).map((reference)=>({
+                kind: 'route',
+                reference
+            }))
+    ];
+};
+const resolveWorkerBundleReference = (issues, outputDirectory, reference, manifestPath)=>{
+    const workerRoot = node_path.resolve(outputDirectory, CLOUDFLARE_WORKER_BUNDLE_DIRECTORY);
+    const workerPath = node_path.resolve(outputDirectory, reference.reference);
+    const relativeToWorkerRoot = node_path.relative(workerRoot, workerPath);
+    if (node_path.isAbsolute(reference.reference) || relativeToWorkerRoot.startsWith('..') || node_path.isAbsolute(relativeToWorkerRoot)) {
+        addIssue(issues, {
+            code: 'invalid-manifest',
+            message: 'Cloudflare output manifest worker bundle references must stay under worker/.',
+            path: manifestPath
+        });
+        return null;
+    }
+    return {
+        ...reference,
+        path: workerPath
+    };
+};
+const missingWorkerBundleMessage = (reference)=>'effect-bff' === reference.kind ? 'Cloudflare Effect BFF manifest points to a missing worker bundle.' : 'Cloudflare route worker manifest points to a missing worker bundle.';
+const isAstNode = (value)=>null !== value && 'object' == typeof value && 'type' in value && 'string' == typeof value.type;
+const getNodeName = (node)=>{
+    if (!isAstNode(node)) return;
+    return 'Identifier' === node.type && 'string' == typeof node.name ? node.name : 'StringLiteral' === node.type && 'string' == typeof node.value ? node.value : void 0;
+};
+const collectBindingNames = (node, names)=>{
+    if (!isAstNode(node)) return;
+    const name = getNodeName(node);
+    if (name) return void names.add(name);
+    if ('ObjectPattern' === node.type && Array.isArray(node.properties)) {
+        for (const property of node.properties)if (isAstNode(property)) collectBindingNames('RestElement' === property.type ? property.argument : property.value, names);
+    } else if ('ArrayPattern' === node.type && Array.isArray(node.elements)) for (const element of node.elements)collectBindingNames(element, names);
+    else if ('AssignmentPattern' === node.type || 'RestElement' === node.type) collectBindingNames('AssignmentPattern' === node.type ? node.left : node.argument, names);
+};
+const getMemberPropertyName = (node)=>'MemberExpression' === node.type ? getNodeName(node.property) : void 0;
+const isModuleExports = (node)=>isAstNode(node) && 'MemberExpression' === node.type && isAstNode(node.object) && 'Identifier' === node.object.type && 'module' === node.object.name && 'exports' === getMemberPropertyName(node);
+const collectCommonJsExports = (statement, exports)=>{
+    if ('ExpressionStatement' !== statement.type || !isAstNode(statement.expression) || 'AssignmentExpression' !== statement.expression.type) return;
+    const { left, right } = statement.expression;
+    if (isAstNode(left) && 'MemberExpression' === left.type && (isAstNode(left.object) && 'Identifier' === left.object.type && 'exports' === left.object.name || isModuleExports(left.object))) {
+        const exportName = getMemberPropertyName(left);
+        if (exportName) exports.add(exportName);
+        return;
+    }
+    if (isModuleExports(left) && isAstNode(right) && 'ObjectExpression' === right.type && Array.isArray(right.properties)) {
+        for (const property of right.properties)if (isAstNode(property)) {
+            const exportName = getNodeName(property.key);
+            if (exportName) exports.add(exportName);
+        }
+    }
+};
+const collectEsmExports = (statement, exports)=>{
+    if ('ExportDefaultDeclaration' === statement.type) return void exports.add('default');
+    if ('ExportNamedDeclaration' !== statement.type) return;
+    if (isAstNode(statement.declaration)) {
+        const declaration = statement.declaration;
+        const declarationName = getNodeName(declaration.id);
+        if (declarationName) exports.add(declarationName);
+        if ('VariableDeclaration' === declaration.type && Array.isArray(declaration.declarations)) {
+            for (const declarator of declaration.declarations)if (isAstNode(declarator)) collectBindingNames(declarator.id, exports);
+        }
+    }
+    if (Array.isArray(statement.specifiers)) {
+        for (const specifier of statement.specifiers)if (isAstNode(specifier)) {
+            const exportName = getNodeName(specifier.exported);
+            if (exportName) exports.add(exportName);
+        }
+    }
+};
+const visitAst = (node, visitor)=>{
+    visitor(node);
+    for (const [key, value] of Object.entries(node))if ('loc' !== key && 'start' !== key && 'end' !== key && 'leadingComments' !== key && 'trailingComments' !== key && 'innerComments' !== key) {
+        if (isAstNode(value)) visitAst(value, visitor);
+        else if (Array.isArray(value)) {
+            for (const item of value)if (isAstNode(item)) visitAst(item, visitor);
+        }
+    }
+};
+const getStaticImport = (node)=>{
+    if (('ImportDeclaration' === node.type || 'ExportNamedDeclaration' === node.type || 'ExportAllDeclaration' === node.type) && isAstNode(node.source)) return getNodeName(node.source);
+    if ('ImportExpression' === node.type && isAstNode(node.source)) return getNodeName(node.source);
+    if ('CallExpression' === node.type && Array.isArray(node.arguments) && 1 === node.arguments.length && isAstNode(node.callee) && ('Identifier' === node.callee.type && 'require' === node.callee.name || 'Import' === node.callee.type)) return getNodeName(node.arguments[0]);
+};
+const analyzeWorkerModule = (source)=>{
+    const ast = parse(source, {
+        sourceType: 'unambiguous'
+    });
+    const exports = new Set();
+    const imports = new Set();
+    for (const statement of ast.program.body){
+        collectEsmExports(statement, exports);
+        collectCommonJsExports(statement, exports);
+    }
+    visitAst(ast.program, (node)=>{
+        const specifier = getStaticImport(node);
+        if (specifier) imports.add(specifier);
+    });
+    return {
+        exports,
+        imports
+    };
+};
+const getPackageName = (specifier)=>specifier.startsWith('@') ? specifier.split('/').slice(0, 2).join('/') : specifier.split('/')[0];
+const CLOUDFLARE_WORKER_NODE_BUILTIN_SPECIFIERS = new Set(CLOUDFLARE_WORKER_NODE_BUILTINS.map((builtin)=>`node:${builtin}`));
+const isInsideDirectory = (directory, filePath)=>{
+    const relative = node_path.relative(directory, filePath);
+    return 0 === relative.length || !relative.startsWith('..') && !node_path.isAbsolute(relative);
+};
+const resolveWorkerModule = async (importer, specifier)=>{
+    const unresolvedPath = node_path.resolve(node_path.dirname(importer), specifier);
+    const candidates = [
+        unresolvedPath,
+        `${unresolvedPath}.js`,
+        `${unresolvedPath}.mjs`,
+        `${unresolvedPath}.cjs`,
+        node_path.join(unresolvedPath, 'index.js'),
+        node_path.join(unresolvedPath, 'index.mjs'),
+        node_path.join(unresolvedPath, 'index.cjs')
+    ];
+    for (const candidate of candidates)try {
+        if ((await promises.stat(candidate)).isFile()) return await promises.realpath(candidate);
+    } catch  {}
+};
+const verifyWorkerModuleClosure = async (issues, entryPath, entrySource, contract)=>{
+    const visited = new Set();
+    let entryAnalysis;
+    const [realWorkerRoot, realEntryPath] = await Promise.all([
+        promises.realpath(contract.workerRoot),
+        promises.realpath(entryPath)
+    ]);
+    if (!isInsideDirectory(realWorkerRoot, realEntryPath)) return void addIssue(issues, {
+        code: 'invalid-worker-bundle',
+        message: 'Cloudflare worker bundles must not resolve outside the staged worker directory.',
+        path: entryPath
+    });
+    const visitModule = async (modulePath, source, isEntry = false)=>{
+        if (visited.has(modulePath)) return;
+        visited.add(modulePath);
+        let analysis;
+        try {
+            analysis = analyzeWorkerModule(source ?? await promises.readFile(modulePath, 'utf-8'));
+        } catch (error) {
+            addIssue(issues, {
+                code: 'invalid-worker-bundle',
+                message: `Cloudflare worker bundle module could not be parsed: ${error instanceof Error ? error.message : String(error)}`,
+                path: modulePath
+            });
+            return;
+        }
+        if (isEntry) entryAnalysis = analysis;
+        for (const specifier of analysis.imports){
+            if (!specifier.startsWith('.') && !node_path.isAbsolute(specifier)) {
+                if (CLOUDFLARE_WORKER_NODE_BUILTIN_SPECIFIERS.has(specifier)) continue;
+                if (specifier.startsWith('node:')) {
+                    addIssue(issues, {
+                        code: 'invalid-worker-bundle',
+                        message: `Cloudflare worker bundle import "${specifier}" is not a supported Worker node: builtin.`,
+                        path: modulePath
+                    });
+                    continue;
+                }
+                if (!contract.providedPackages.has(getPackageName(specifier))) addIssue(issues, {
+                    code: 'invalid-worker-bundle',
+                    message: `Cloudflare worker bundle import "${specifier}" is not provided by worker/package.json dependencies.`,
+                    path: modulePath
+                });
+                continue;
+            }
+            const resolved = await resolveWorkerModule(modulePath, specifier);
+            if (resolved && !isInsideDirectory(realWorkerRoot, resolved)) {
+                addIssue(issues, {
+                    code: 'invalid-worker-bundle',
+                    message: 'Cloudflare worker bundles must not resolve outside the staged worker directory.',
+                    path: modulePath
+                });
+                continue;
+            }
+            if (!resolved) {
+                addIssue(issues, {
+                    code: 'invalid-worker-bundle',
+                    message: `Cloudflare worker bundle import "${specifier}" does not resolve inside worker/.`,
+                    path: modulePath
+                });
+                continue;
+            }
+            await visitModule(resolved);
+        }
+    };
+    await visitModule(realEntryPath, entrySource, true);
+    return entryAnalysis;
+};
+const verifyWorkerBundleReferences = async (issues, worker, source, contract)=>{
+    const entryAnalysis = await verifyWorkerModuleClosure(issues, worker.path, source, contract);
+    if ('effect-bff' === worker.kind && 'string' == typeof worker.dispatcherExport && !entryAnalysis?.exports.has(worker.dispatcherExport)) addIssue(issues, {
+        code: 'invalid-worker-bundle',
+        message: 'Cloudflare Effect BFF worker bundle must expose its manifest dispatcherExport.',
+        path: worker.path
+    });
+};
+const verifyWorkerImport = async (issues, entryPath)=>{
+    try {
+        const worker = (await import(`${pathToFileURL(entryPath).href}?t=${Date.now()}`)).default;
+        if (!worker || 'function' != typeof worker.fetch) addIssue(issues, {
+            code: 'worker-import-failed',
+            message: 'Cloudflare server entry must default-export a Worker with fetch.',
+            path: entryPath
+        });
+    } catch (error) {
+        addIssue(issues, {
+            code: 'worker-import-failed',
+            message: `Cloudflare server entry could not be imported: ${error instanceof Error ? error.message : String(error)}`,
+            path: entryPath
+        });
+    }
+};
+export { getEffectBffWorker, getWorkerBundleReferences, missingWorkerBundleMessage, resolveWorkerBundleReference, verifyWorkerBundleReferences, verifyWorkerImport };

package/dist/esm-node/plugins/deploy/platforms/node.mjs

@@ -5,7 +5,8 @@ import { chalk, fs, removeModuleSyncFromExports } from "@modern-js/utils";
 import { nodeDepEmit } from "ndepe";
 import { readTemplate, resolveESMDependency } from "../utils/index.mjs";
 import { generateHandler } from "../utils/generator.mjs";
-const createNodePreset = ({ appContext, modernConfig, api })=>{
+import { preserveNpmAliases, readPackageIdentity } from "../utils/npmAliases.mjs";
+const createNodePreset = ({ appContext, modernConfig })=>{
     const { appDirectory, distDirectory, moduleType } = appContext;
     const isEsmProject = 'module' === moduleType;
     const outputDirectory = node_path.join(appDirectory, '.output');
@@ -16,7 +17,12 @@ const createNodePreset = ({ appContext, modernConfig, api })=>{
             await fs.remove(outputDirectory);
         },
         async writeOutput () {
-            await fs.copy(distDirectory, outputDirectory);
+            await fs.copy(distDirectory, outputDirectory, {
+                filter: (src)=>{
+                    const relativePath = node_path.relative(distDirectory, src).replace(/\\/gu, '/');
+                    return 'release' !== relativePath && !relativePath.startsWith('release/');
+                }
+            });
         },
         async genEntry () {
             const template = await readTemplate(`node-entry.${isEsmProject ? 'mjs' : 'cjs'}`);
@@ -32,6 +38,7 @@ const createNodePreset = ({ appContext, modernConfig, api })=>{
             const filter = (filePath)=>!filePath.startsWith(staticDirectory) && !filePath.endsWith('.map');
             const entry = isEsmProject ? await resolveESMDependency('@modern-js/prod-server') : require.resolve('@modern-js/prod-server');
             if (!entry) throw new Error('Cannot find @modern-js/prod-server');
+            const prodServerPackage = await readPackageIdentity(entry);
             await nodeDepEmit({
                 appDir: appDirectory,
                 sourceDir: outputDirectory,
@@ -50,6 +57,17 @@ const createNodePreset = ({ appContext, modernConfig, api })=>{
                     };
                 }
             });
+            await preserveNpmAliases({
+                appDirectory,
+                outputDirectory,
+                implicitAliases: [
+                    {
+                        aliasName: '@modern-js/prod-server',
+                        targetName: prodServerPackage.name,
+                        targetVersion: prodServerPackage.version
+                    }
+                ]
+            });
             console.log('Static directory:', chalk.blue(node_path.relative(appDirectory, staticDirectory).replace(/\\/g, '/')));
             console.log("You can preview this build by", chalk.blue('node .output/index'));
         }