@bleedingdev/modern-js-code-tools 3.9.0-ultramodern.1 → 3.9.0-ultramodern.10

package/dist/esm-node/microvertical-api-boundary.js

@@ -0,0 +1,450 @@
+import "node:module";
+import node_fs from "node:fs";
+import node_path from "node:path";
+import { parse } from "@babel/parser";
+import { configuredMicroVerticalApiStem, consumerParserPlugins, microVerticalApiBaselineViolation } from "./microvertical-api-baseline.js";
+import { baselinePackage, resolveBaselinePackageDirectory } from "./microvertical-api-owner.js";
+import { createEffectApiImportResolver, strictEffectRuntimeTopologyViolation } from "./strict-effect-runtime.js";
+import * as __rspack_external__babel_types_6e8337dd from "@babel/types";
+const ignored = new Set([
+    '.git',
+    '.modern',
+    '.modernjs',
+    '.output',
+    'coverage',
+    'dist',
+    'node_modules',
+    'repos'
+]);
+const normalize = (file)=>file.split(node_path.sep).join('/').replace(/^\.\//u, '');
+const errorMessage = (error)=>error instanceof Error ? error.message : String(error);
+const apiApp = (app)=>'vertical' === app.kind && 'ui-only' !== app.surfaceProfile && 'horizontal-remote' !== app.deliveryUnitKind;
+function configuredApps(root, supplied) {
+    const source = supplied ?? JSON.parse(node_fs.readFileSync(node_path.join(root, '.modernjs/ultramodern.json'), 'utf8')).topology?.apps;
+    if (!Array.isArray(source)) throw new Error('.modernjs/ultramodern.json: topology.apps must be an array');
+    const paths = new Set();
+    for (const app of source){
+        if (!app || 'object' != typeof app || 'string' != typeof app.path || !app.path || node_path.isAbsolute(app.path) || app.path.split(/[\\/]/u).includes('..')) throw new Error('.modernjs/ultramodern.json: each app must have a relative workspace path');
+        const key = normalize(app.path);
+        if (paths.has(key)) throw new Error(`.modernjs/ultramodern.json: duplicate app path ${key}`);
+        paths.add(key);
+        for (const name of [
+            'id',
+            'kind',
+            'package',
+            'surfaceProfile',
+            'deliveryUnitKind'
+        ])if (void 0 !== app[name] && 'string' != typeof app[name]) throw new Error(`${key}: ${name} must be a string`);
+        for (const [field, allowed] of Object.entries({
+            kind: [
+                'shell',
+                'vertical'
+            ],
+            surfaceProfile: [
+                'full-stack',
+                'api-only',
+                'ui-only'
+            ],
+            deliveryUnitKind: [
+                'microvertical',
+                'horizontal-remote'
+            ]
+        }))if (void 0 !== app[field] && !allowed.includes(app[field])) throw new Error(`${key}: invalid ${field}`);
+        if (void 0 !== app.api) {
+            if (!app.api || 'object' != typeof app.api || Array.isArray(app.api)) throw new Error(`${key}: api must be an object`);
+            if (void 0 !== app.api.protocol && ![
+                'rest',
+                'rpc'
+            ].includes(app.api.protocol)) throw new Error(`${key}: api.protocol must be rest or rpc`);
+            if (void 0 !== app.api.stem && ('string' != typeof app.api.stem || !/^[a-z0-9]+(?:-[a-z0-9]+)*$/u.test(app.api.stem))) throw new Error(`${key}: invalid api.stem`);
+            if (void 0 !== app.api.prefix && ('string' != typeof app.api.prefix || !/^\/[^\s?#]*$/u.test(app.api.prefix))) throw new Error(`${key}: invalid api.prefix`);
+            for (const field of [
+                'additionalPaths',
+                'operationPaths'
+            ]){
+                const value = app.api[field];
+                if (void 0 !== value && (!value || 'object' != typeof value || Array.isArray(value) || Object.values(value).some((entry)=>'string' != typeof entry))) throw new Error(`${key}: api.${field} must map names to paths`);
+            }
+        }
+    }
+    return source;
+}
+function check(options, topology) {
+    const diagnostics = [];
+    const toolErrors = [];
+    let topologyFilesAnalyzed = 0;
+    const root = node_path.resolve(options.workspaceRoot);
+    const absolute = (file)=>node_path.join(root, file);
+    const exists = (file)=>node_fs.existsSync(absolute(file));
+    const read = (file)=>node_fs.readFileSync(absolute(file), 'utf8');
+    const assert = (value, message)=>{
+        if (!value) diagnostics.push(message);
+    };
+    const noPath = (file, reason)=>assert(!exists(file), `${file}: ${reason}`);
+    const guarded = (file, work)=>{
+        try {
+            work();
+        } catch (error) {
+            toolErrors.push(`${file}: ${errorMessage(error)}`);
+        }
+    };
+    try {
+        const apps = configuredApps(root, options.configuredApps);
+        const byPath = new Map(apps.map((app)=>[
+                normalize(app.path),
+                app
+            ]));
+        const directories = (base)=>exists(base) ? node_fs.readdirSync(absolute(base), {
+                withFileTypes: true
+            }).filter((entry)=>entry.isDirectory() && !ignored.has(entry.name)).map((entry)=>`${base}/${entry.name}`) : [];
+        const walk = (directory)=>exists(directory) ? node_fs.readdirSync(absolute(directory), {
+                withFileTypes: true
+            }).flatMap((entry)=>{
+                if (ignored.has(entry.name) || 'dist-cloudflare' === entry.name && byPath.has(directory)) return [];
+                const file = `${directory}/${entry.name}`;
+                return entry.isDirectory() ? walk(file) : entry.isFile() ? [
+                    file
+                ] : [];
+            }) : [];
+        const parsed = new Map();
+        const parseFile = (file)=>{
+            if (parsed.has(file)) return parsed.get(file);
+            if (node_fs.statSync(absolute(file)).size > 1000000) throw new Error('consumer source exceeds 1 MB analysis budget');
+            try {
+                const ast = parse(read(file), {
+                    sourceType: 'module',
+                    sourceFilename: file,
+                    plugins: consumerParserPlugins(file)
+                });
+                parsed.set(file, ast);
+                return ast;
+            } catch (error) {
+                if ('object' == typeof error && null !== error && 'code' in error && 'BABEL_PARSER_SYNTAX_ERROR' === error.code) {
+                    diagnostics.push(`${file}: invalid source syntax (${errorMessage(error)})`);
+                    parsed.set(file, void 0);
+                    return;
+                }
+                throw error;
+            }
+        };
+        const resolveRelative = (fromFile, specifier)=>{
+            if (!/^\.\.?\//u.test(specifier)) return;
+            const base = node_path.posix.join(node_path.posix.dirname(fromFile), specifier).replace(/\.(?:[cm]?[jt]sx?)$/u, '');
+            return [
+                `${base}.ts`,
+                `${base}.tsx`,
+                `${base}/index.ts`,
+                `${base}/index.tsx`
+            ].find((candidate)=>exists(candidate));
+        };
+        const composedModules = (file)=>{
+            const order = [];
+            const seen = new Set();
+            const queue = [
+                file
+            ];
+            while(queue.length > 0 && order.length < 128){
+                const current = queue.shift();
+                if (seen.has(current)) continue;
+                seen.add(current);
+                order.push(current);
+                const ast = parseFile(current);
+                if (!ast) continue;
+                for (const statement of ast.program.body){
+                    const source = (__rspack_external__babel_types_6e8337dd.isImportDeclaration(statement) || __rspack_external__babel_types_6e8337dd.isExportNamedDeclaration(statement) || __rspack_external__babel_types_6e8337dd.isExportAllDeclaration(statement)) && statement.source ? statement.source.value : void 0;
+                    const resolved = void 0 === source ? void 0 : resolveRelative(current, source);
+                    if (void 0 !== resolved && !seen.has(resolved)) queue.push(resolved);
+                }
+            }
+            return order;
+        };
+        const moduleShape = (file, imports, calls, patterns = [], defaultExport, composed = false)=>{
+            if (!exists(file)) return;
+            const ast = parseFile(file);
+            if (!ast) return;
+            const shapeFiles = composed ? composedModules(file) : [
+                file
+            ];
+            const body = shapeFiles.flatMap((shapeFile)=>parseFile(shapeFile)?.program.body ?? []);
+            for (const [specifier, names] of imports){
+                const target = resolveRelative(file, specifier);
+                const matchesSpecifier = (item, from)=>void 0 === target ? item.source.value === specifier : resolveRelative(from, item.source.value) === target;
+                const imported = shapeFiles.flatMap((shapeFile)=>(parseFile(shapeFile)?.program.body ?? []).filter((item)=>__rspack_external__babel_types_6e8337dd.isImportDeclaration(item) && 'type' !== item.importKind && matchesSpecifier(item, shapeFile)));
+                assert(imported.length, `${file}: must import from ${specifier}`);
+                for (const name of names)assert(imported.some((item)=>__rspack_external__babel_types_6e8337dd.isImportDeclaration(item) && item.specifiers.some((value)=>__rspack_external__babel_types_6e8337dd.isImportSpecifier(value) && 'type' !== value.importKind && __rspack_external__babel_types_6e8337dd.isIdentifier(value.imported, {
+                            name
+                        }) && __rspack_external__babel_types_6e8337dd.isIdentifier(value.local, {
+                            name
+                        }))), `${file}: must import ${name} from ${specifier}`);
+            }
+            const found = new Set();
+            const collectCalls = (node)=>{
+                if (!__rspack_external__babel_types_6e8337dd.isCallExpression(node)) return;
+                if (__rspack_external__babel_types_6e8337dd.isIdentifier(node.callee)) found.add(node.callee.name);
+                if (__rspack_external__babel_types_6e8337dd.isMemberExpression(node.callee) && !node.callee.computed && __rspack_external__babel_types_6e8337dd.isIdentifier(node.callee.object) && __rspack_external__babel_types_6e8337dd.isIdentifier(node.callee.property)) found.add(`${node.callee.object.name}.${node.callee.property.name}`);
+            };
+            for (const shapeFile of shapeFiles){
+                const shapeAst = parseFile(shapeFile);
+                if (shapeAst) __rspack_external__babel_types_6e8337dd.traverseFast(shapeAst, collectCalls);
+            }
+            for (const call of calls)assert(found.has(call), `${file}: must call ${call}(...)`);
+            const source = read(file).replace(/\/\*[\s\S]*?\*\/|\/\/[^\n]*/gu, '');
+            for (const [pattern, reason] of patterns)assert(pattern.test(source), `${file}: ${reason}`);
+            if (defaultExport) assert(body.some((item)=>__rspack_external__babel_types_6e8337dd.isExportDefaultDeclaration(item) && __rspack_external__babel_types_6e8337dd.isIdentifier(item.declaration, {
+                    name: defaultExport
+                })), `${file}: must default-export ${defaultExport}`);
+        };
+        const effect = '@modern-js/bff-effect/effect-client';
+        const appDirectories = [
+            ...new Set([
+                ...directories('apps'),
+                ...directories('verticals'),
+                ...byPath.keys()
+            ])
+        ];
+        for (const appPath of appDirectories)for (const suffix of [
+            'api/effect',
+            'api/lambda',
+            'shared/effect',
+            'src/effect'
+        ])noPath(`${appPath}/${suffix}`, 'legacy nested Effect paths are forbidden; use api/index.ts, shared/api.ts and src/api/*');
+        const sourceFiles = [
+            ...new Set([
+                'apps',
+                'verticals',
+                'packages',
+                ...byPath.keys()
+            ].flatMap(walk))
+        ].filter((file)=>/\.(?:[cm]?[jt]sx?|json|md)$/u.test(file));
+        for (const file of sourceFiles)guarded(file, ()=>{
+            const source = read(file);
+            const patterns = [
+                [
+                    /@modern-js\/plugin-bff\/(?:server|hono-server)(?![\w-])/u,
+                    'use Effect HttpApi instead of Hono helpers'
+                ],
+                [
+                    /\bruntimeFramework\s*(?::|=)\s*['"]hono['"]/u,
+                    'must use the Effect runtime'
+                ],
+                [
+                    /\bstrictEffectApproach\s*(?::|=)\s*false\b/u,
+                    'must keep strictEffectApproach enabled'
+                ]
+            ];
+            if (/\/api\//u.test(file)) patterns.push([
+                /\bnew\s+Response\s*\(|\bResponse\.json\s*\(/u,
+                'must not hand-build Response objects'
+            ], [
+                /\b(?:request|req)\.(?:json|text|formData|arrayBuffer)\s*\(/u,
+                'must use endpoint payload/query/params schemas instead of parsing request bodies'
+            ], [
+                /\bexport\s+const\s+handler\b|\bexport\s+default\s+async\b/u,
+                'must not export raw request handlers'
+            ], [
+                /\bcreateHandler\s*[:=]\s*(?!defineEffectBff\b)/u,
+                'must use defineEffectBff instead of unbranded handler factories'
+            ], [
+                /\bSchema\.(?:UnknownFromJsonString|Unknown|Any)\b/u,
+                'must use concrete request, response and error schemas'
+            ]);
+            for (const [pattern, reason] of patterns)assert(!pattern.test(source), `${file}: ${reason}`);
+            if (topology && /\/api\/index\.ts$/u.test(file)) {
+                topologyFilesAnalyzed += 1;
+                const violation = strictEffectRuntimeTopologyViolation(source, createEffectApiImportResolver(absolute(file)));
+                if (violation) diagnostics.push(`${file}: ${violation}`);
+            }
+        });
+        let owner;
+        for (const appPath of appDirectories)guarded(appPath, ()=>{
+            const app = byPath.get(appPath);
+            const emits = app ? apiApp(app) || 'vertical' !== app.kind && void 0 !== app.api : appPath.startsWith('verticals/') || exists(`${appPath}/api/index.ts`) || exists(`${appPath}/shared/api.ts`);
+            if (!emits) {
+                if (app?.kind === 'vertical') {
+                    assert(void 0 === app.api, `${appPath}: UI/horizontal unit must not declare an API`);
+                    for (const suffix of [
+                        'api/index.ts',
+                        'api/effect-api.ts',
+                        'shared/api.ts',
+                        'shared/rpc.ts',
+                        'src/api'
+                    ])noPath(`${appPath}/${suffix}`, 'unit has no API surface');
+                }
+                return;
+            }
+            if (app?.kind === 'vertical') assert(void 0 !== app.api, `${appPath}: vertical must declare its Effect API in .modernjs/ultramodern.json`);
+            const stem = app?.api?.stem ?? node_path.posix.basename(appPath);
+            const rpc = app?.api?.protocol === 'rpc';
+            const contract = `${appPath}/shared/${rpc ? 'rpc' : 'api'}.ts`;
+            const client = `${appPath}/src/api/${stem}-${rpc ? 'rpc-client' : 'client'}.ts`;
+            const entry = `${appPath}/api/index.ts`;
+            for (const file of [
+                entry,
+                contract,
+                client
+            ])assert(exists(file), `${file}: required API surface is missing`);
+            noPath(`${appPath}/shared/${rpc ? 'api' : 'rpc'}.ts`, `must not emit a ${rpc ? 'REST' : 'RPC'} contract`);
+            noPath(`${appPath}/src/api/${stem}-${rpc ? 'client' : 'rpc-client'}.ts`, `must not emit a ${rpc ? 'REST' : 'RPC'} client`);
+            if (rpc) {
+                moduleShape(entry, [
+                    [
+                        '@modern-js/bff-effect/effect-edge',
+                        [
+                            'defineEffectBff',
+                            'Effect',
+                            'HttpApi',
+                            'Layer'
+                        ]
+                    ],
+                    [
+                        '../shared/rpc.ts',
+                        []
+                    ]
+                ], [
+                    'defineEffectBff',
+                    'HttpApi.make'
+                ], [
+                    [
+                        /\bconst\s+\w+RpcLayer\s*=\s*\w+RpcGroup\s*\.\s*toLayer\s*\(/u,
+                        'must implement RpcGroup.toLayer(...)'
+                    ],
+                    [
+                        /\brpc\s*:\s*\{[\s\S]*?\bgroup\s*:[\s\S]*?\blayer\s*:[\s\S]*?\bpath\s*:[\s\S]*?\bserialization\s*:/u,
+                        'must register RPC group, layer, path and serialization'
+                    ]
+                ], 'apiRuntime');
+                moduleShape(contract, [
+                    [
+                        'effect/unstable/rpc',
+                        [
+                            'Rpc',
+                            'RpcGroup'
+                        ]
+                    ],
+                    [
+                        effect,
+                        [
+                            'Schema'
+                        ]
+                    ]
+                ], [
+                    'RpcGroup.make',
+                    'Rpc.make',
+                    'Schema.Struct'
+                ]);
+            } else if (exists(contract)) {
+                owner ??= options.baselinePackageDirectory ?? resolveBaselinePackageDirectory(node_path.join(root, 'package.json'));
+                const apiPrefix = app?.api?.prefix ?? `/${stem}-api`;
+                const basePath = `${apiPrefix}/${stem}`;
+                const expectation = {
+                    operationPaths: app?.api?.operationPaths,
+                    additionalPaths: app?.api?.additionalPaths ?? {},
+                    apiPrefix,
+                    basePath,
+                    effectClientPackage: effect,
+                    ownerId: app?.id ?? node_path.posix.basename(appPath),
+                    readinessPath: `${basePath}/readiness`,
+                    baselinePackage: baselinePackage,
+                    baselinePackageDirectory: owner
+                };
+                const violation = microVerticalApiBaselineViolation(stem, absolute(contract), expectation);
+                if (violation) diagnostics.push(`${contract}: ${violation}`);
+            }
+            moduleShape(client, [
+                [
+                    effect,
+                    [
+                        'Effect',
+                        rpc ? 'makeEffectRpcClient' : 'makeEffectHttpApiClient'
+                    ]
+                ],
+                [
+                    rpc ? '../../shared/rpc.ts' : '../../shared/api',
+                    []
+                ]
+            ], [
+                rpc ? 'makeEffectRpcClient' : 'makeEffectHttpApiClient'
+            ], [], void 0, true);
+            moduleShape(`${appPath}/api/effect-api.ts`, [], [], [
+                [
+                    /\bbackendFederationContract\b/u,
+                    'must export backendFederationContract metadata'
+                ],
+                [
+                    /role:\s*['"]microvertical-server['"]/u,
+                    'must describe the MicroVertical server role'
+                ],
+                [
+                    /strictEffectApproach:\s*true/u,
+                    'must preserve strict Effect backend execution'
+                ],
+                [
+                    /contractVersion:\s*['"]microvertical-server-effect-v1['"]/u,
+                    'must preserve the server contract version'
+                ],
+                [
+                    /export\s*\{\s*default\s*,\s*default\s+as\s+runtime\s*\}\s+from\s+['"]\.\/index\.ts['"]/u,
+                    'must re-export the runtime as default and runtime'
+                ],
+                [
+                    /^(?![\s\S]*\b(request|handler)\s*:\s*async\s*\()/u,
+                    'must not expose raw request handlers'
+                ]
+            ]);
+            moduleShape(`${appPath}/modern.config.ts`, [], [], [
+                [
+                    /runtimeFramework:\s*['"]effect['"]/u,
+                    'must use bff.runtimeFramework: effect'
+                ],
+                [
+                    /entry:\s*['"]\.\/api\/index['"]/u,
+                    'must use ./api/index'
+                ],
+                [
+                    /strictEffectApproach:\s*true/u,
+                    'must enable strictEffectApproach'
+                ]
+            ]);
+            const packageFile = `${appPath}/package.json`;
+            if (exists(packageFile)) {
+                const manifest = JSON.parse(read(packageFile));
+                assert(manifest.exports?.['./api'] === `./shared/${rpc ? 'rpc' : 'api'}.ts`, `${packageFile}: invalid ./api export`);
+                assert(manifest.exports?.[`./api/${rpc ? 'rpc-client' : 'client'}`] === `./src/api/${stem}-${rpc ? 'rpc-client' : 'client'}.ts`, `${packageFile}: invalid API client export`);
+                assert(manifest.exports?.[`./api/${rpc ? 'client' : 'rpc-client'}`] === void 0, `${packageFile}: forbidden opposite protocol client export`);
+            }
+        });
+        const shell = 'apps/shell-super-app';
+        const verticals = apps.filter((app)=>app.path.startsWith('verticals/') && apiApp(app));
+        if (exists(shell) && verticals.length) {
+            const file = `${shell}/src/api/vertical-clients.ts`;
+            assert(exists(file), `${file}: must aggregate vertical API clients`);
+            if (exists(file)) guarded(file, ()=>{
+                const ast = parseFile(file);
+                for (const app of verticals){
+                    const specifier = `${app.package}/api/${app.api?.protocol === 'rpc' ? 'rpc-client' : 'client'}`;
+                    assert(ast?.program.body.some((item)=>__rspack_external__babel_types_6e8337dd.isExportNamedDeclaration(item) && item.source?.value === specifier), `${file}: must re-export ${specifier}`);
+                }
+            });
+        }
+        if (exists(`${shell}/package.json`)) guarded(`${shell}/package.json`, ()=>assert(JSON.parse(read(`${shell}/package.json`)).exports?.['./api/clients'] === './src/api/vertical-clients.ts', `${shell}/package.json: must export ./api/clients`));
+        if (exists('topology/reference-topology.json')) guarded('topology/reference-topology.json', ()=>{
+            for (const vertical of JSON.parse(read('topology/reference-topology.json')).verticals ?? []){
+                if (vertical.api?.runtime === 'effect') {
+                    assert(vertical.api.bff?.strictEffectApproach === true, `${vertical.id}: topology must mark strictEffectApproach true`);
+                    assert('string' == typeof vertical.api.serverEntry && vertical.api.serverEntry.endsWith('/api/index.ts'), `${vertical.id}: topology must use api/index.ts`);
+                }
+                assert(!vertical.api?.effect, `${vertical.id}: topology must describe API directly, not api.effect`);
+            }
+        });
+    } catch (error) {
+        toolErrors.push(errorMessage(error));
+    }
+    return {
+        diagnostics,
+        toolErrors,
+        topologyFilesAnalyzed
+    };
+}
+const checkMicroVerticalApiBoundaries = (options)=>check(options, true);
+const checkMicroVerticalApiConsumerFiles = (options)=>check(options, false);
+export { checkMicroVerticalApiBoundaries, checkMicroVerticalApiConsumerFiles, configuredMicroVerticalApiStem, microVerticalApiBaselineViolation };

package/dist/esm-node/microvertical-api-owner.js

@@ -0,0 +1,163 @@
+import "node:module";
+import node_fs from "node:fs";
+import { createRequire } from "node:module";
+import node_path from "node:path";
+import { parse } from "@babel/parser";
+import * as __rspack_external__babel_types_6e8337dd from "@babel/types";
+const baselinePackage = '@modern-js/bff-effect/microvertical-api';
+const ownerName = '@modern-js/bff-effect';
+const within = (root, file)=>file.startsWith(`${root}${node_path.sep}`);
+function resolveBaselinePackageDirectory(fromFile) {
+    const lookup = createRequire(fromFile).resolve.paths(baselinePackage);
+    for (const directory of lookup ?? []){
+        const candidate = node_path.join(directory, ownerName);
+        if (!node_fs.existsSync(candidate)) continue;
+        const root = node_fs.realpathSync(candidate);
+        const manifest = JSON.parse(node_fs.readFileSync(node_path.join(root, 'package.json'), 'utf8'));
+        if (![
+            ownerName,
+            '@bleedingdev/modern-js-bff-effect'
+        ].includes(manifest.name)) throw new Error(`${fromFile}: ${baselinePackage} resolved to unrelated package ${String(manifest.name)}`);
+        const target = importTarget(manifest.exports?.['./microvertical-api']);
+        if (!target?.startsWith('./')) throw new Error(`${fromFile}: ${baselinePackage} has no public Node import export`);
+        node_fs.statSync(node_path.resolve(root, target));
+        return root;
+    }
+    throw new Error(`${fromFile}: cannot resolve installed ${baselinePackage}`);
+}
+function importTarget(value) {
+    if ('string' == typeof value) return value;
+    if (!value || 'object' != typeof value || Array.isArray(value)) return;
+    for (const [condition, target] of Object.entries(value))if ([
+        'node',
+        'import',
+        'default'
+    ].includes(condition)) {
+        const resolved = importTarget(target);
+        if (resolved) return resolved;
+    }
+}
+function baselinePublicIdentityIsExact(fromFile, expectation) {
+    const owner = node_fs.realpathSync(expectation.baselinePackageDirectory);
+    const manifest = JSON.parse(node_fs.readFileSync(node_path.join(owner, 'package.json'), 'utf8'));
+    if (expectation.baselinePackage !== baselinePackage || ![
+        ownerName,
+        '@bleedingdev/modern-js-bff-effect'
+    ].includes(manifest.name)) return false;
+    let resolvedOwner;
+    try {
+        resolvedOwner = resolveBaselinePackageDirectory(fromFile);
+    } catch (error) {
+        if (error instanceof Error && error.message.includes('resolved to unrelated package')) return false;
+        throw error;
+    }
+    if (resolvedOwner !== owner) return false;
+    const target = importTarget(manifest.exports?.['./microvertical-api']);
+    if (!target?.startsWith('./')) return false;
+    const modules = new Map();
+    const load = (filename)=>{
+        const real = node_fs.realpathSync(filename);
+        if (!within(owner, real)) return;
+        let file = modules.get(real);
+        if (!file) {
+            if (modules.size >= 64 || node_fs.statSync(real).size > 1000000) throw new Error(`${real}: public export analysis budget exceeded`);
+            file = parse(node_fs.readFileSync(real, 'utf8'), {
+                sourceType: 'module',
+                sourceFilename: real,
+                plugins: [
+                    "typescript"
+                ]
+            });
+            modules.set(real, file);
+        }
+        return {
+            file,
+            real
+        };
+    };
+    const follow = (from, specifier)=>{
+        if (!specifier.startsWith('.')) return;
+        const candidate = node_path.resolve(node_path.dirname(from), specifier);
+        if (!within(owner, candidate)) return;
+        return [
+            candidate,
+            `${candidate}.ts`,
+            `${candidate}.js`,
+            node_path.join(candidate, 'index.ts'),
+            node_path.join(candidate, 'index.js')
+        ].find((file)=>node_fs.existsSync(file) && node_fs.statSync(file).isFile());
+    };
+    const exportedOwner = (filename, name, seen = new Set())=>{
+        const loaded = load(filename);
+        if (!loaded) return;
+        const { file, real } = loaded;
+        const key = `${real}:${name}`;
+        if (seen.has(key)) return;
+        seen = new Set([
+            ...seen,
+            key
+        ]);
+        const explicit = [];
+        const stars = [];
+        for (const statement of file.program.body){
+            if (__rspack_external__babel_types_6e8337dd.isExportAllDeclaration(statement) && 'type' !== statement.exportKind) {
+                const next = follow(real, statement.source.value);
+                if (!next) return;
+                stars.push(next);
+            }
+            if (!__rspack_external__babel_types_6e8337dd.isExportNamedDeclaration(statement) || 'type' === statement.exportKind) continue;
+            const declaration = statement.declaration;
+            if (__rspack_external__babel_types_6e8337dd.isVariableDeclaration(declaration) && declaration.declarations.some((value)=>__rspack_external__babel_types_6e8337dd.isIdentifier(value.id, {
+                    name
+                }))) explicit.push(real);
+            if ((__rspack_external__babel_types_6e8337dd.isFunctionDeclaration(declaration) || __rspack_external__babel_types_6e8337dd.isClassDeclaration(declaration)) && __rspack_external__babel_types_6e8337dd.isIdentifier(declaration.id, {
+                name
+            })) explicit.push(real);
+            for (const value of statement.specifiers)if (__rspack_external__babel_types_6e8337dd.isExportSpecifier(value) && 'type' !== value.exportKind && __rspack_external__babel_types_6e8337dd.isIdentifier(value.exported, {
+                name
+            })) {
+                if (!__rspack_external__babel_types_6e8337dd.isIdentifier(value.local, {
+                    name
+                })) {
+                    explicit.push(void 0);
+                    continue;
+                }
+                if (statement.source) {
+                    const next = follow(real, statement.source.value);
+                    explicit.push(next ? exportedOwner(next, name, seen) : void 0);
+                } else {
+                    const local = file.program.body.find((item)=>__rspack_external__babel_types_6e8337dd.isVariableDeclaration(item) && item.declarations.some((value)=>__rspack_external__babel_types_6e8337dd.isIdentifier(value.id, {
+                                name
+                            })) || (__rspack_external__babel_types_6e8337dd.isFunctionDeclaration(item) || __rspack_external__babel_types_6e8337dd.isClassDeclaration(item)) && __rspack_external__babel_types_6e8337dd.isIdentifier(item.id, {
+                            name
+                        }));
+                    if (local) {
+                        explicit.push(real);
+                        continue;
+                    }
+                    const imported = file.program.body.find((item)=>__rspack_external__babel_types_6e8337dd.isImportDeclaration(item) && 'type' !== item.importKind && item.specifiers.some((value)=>__rspack_external__babel_types_6e8337dd.isImportSpecifier(value) && 'type' !== value.importKind && __rspack_external__babel_types_6e8337dd.isIdentifier(value.local, {
+                                name
+                            }) && __rspack_external__babel_types_6e8337dd.isIdentifier(value.imported, {
+                                name
+                            })));
+                    const next = __rspack_external__babel_types_6e8337dd.isImportDeclaration(imported) ? follow(real, imported.source.value) : void 0;
+                    explicit.push(next ? exportedOwner(next, name, seen) : void 0);
+                }
+            }
+        }
+        if (explicit.length) return 1 === explicit.length ? explicit[0] : void 0;
+        const owners = stars.map((next)=>exportedOwner(next, name, seen));
+        const unique = new Set(owners.filter((value)=>void 0 !== value));
+        return 1 === unique.size ? [
+            ...unique
+        ][0] : void 0;
+    };
+    const entry = node_path.resolve(owner, target);
+    const owners = [
+        'MicroVerticalBuildMarkerSchema',
+        'MicroVerticalReadinessSchema',
+        'createMicroVerticalOperationContext'
+    ].map((name)=>exportedOwner(entry, name));
+    return void 0 !== owners[0] && owners.every((value)=>value === owners[0]);
+}
+export { baselinePackage, baselinePublicIdentityIsExact, resolveBaselinePackageDirectory };

package/dist/esm-node/oxlint-plugin/rules/strict-effect-api-boundaries.js

@@ -1,4 +1,5 @@
 import "node:module";
+import { createEffectApiImportResolver, strictEffectRuntimeTopologyViolation } from "../../strict-effect-runtime.js";
 import { getSourceText, isApiEntryFile, isApiSourceFile, isForbiddenGeneratedEffectPath, isSharedApiContractFile, normalizeFilename, reportMissingProgramPattern, reportProgramPattern } from "../ast.js";
 const createStrictEffectApiBoundariesRule = ()=>({
         meta: {
@@ -18,15 +19,16 @@ const createStrictEffectApiBoundariesRule = ()=>({
                         node,
                         message: 'Generated UltraModern workspaces use direct api/index.ts, shared/api.ts and src/api/* paths; api/effect, api/lambda, shared/effect and src/effect are forbidden.'
                     });
-                    reportProgramPattern(context, node, source, /@modern-js\/plugin-bff\/hono-server/u, 'UltraModern API workspaces must not import Hono server helpers; use @modern-js/plugin-bff/effect-edge and HttpApi.');
+                    reportProgramPattern(context, node, source, /@modern-js\/plugin-bff\/(?:server|hono-server)(?![\w-])/u, 'UltraModern API workspaces must not import Hono server helpers; use @modern-js/bff-effect/effect-edge and HttpApi.');
                     reportProgramPattern(context, node, source, /\bruntimeFramework\s*(?::|=)\s*['"]hono['"]/u, 'UltraModern API apps must use bff.runtimeFramework: "effect".');
                     reportProgramPattern(context, node, source, /(?:from|import)\s*['"][^'"]*(?:api\/effect|shared\/effect)[^'"]*['"]|shared-effect-api/u, 'Import API code from direct api/index.ts, shared/api.ts or src/api/* paths, not api/effect, shared/effect or shared Effect API packages.');
                     reportProgramPattern(context, node, source, /\bstrictEffectApproach\s*(?::|=)\s*false\b/u, 'UltraModern API apps must keep strictEffectApproach enabled.');
                     if (isApiEntryFile(filename)) {
-                        reportMissingProgramPattern(context, node, source, /\bdefineEffectBff\b/u, 'Generated API entries must export defineEffectBff(...).');
-                        reportMissingProgramPattern(context, node, source, /\bHttpApiBuilder\b/u, 'Generated API entries must implement handlers through HttpApiBuilder.');
-                        reportMissingProgramPattern(context, node, source, /\bLayer\b/u, 'Generated API entries must compose dependencies with Effect Layer.');
-                        reportMissingProgramPattern(context, node, source, /from\s+['"]\.\.\/shared\/api\.ts['"]/u, 'Generated API entries must import the contract from ../shared/api.ts.');
+                        const violation = strictEffectRuntimeTopologyViolation(source, createEffectApiImportResolver(filename));
+                        if (violation) context.report({
+                            node,
+                            message: violation
+                        });
                     }
                     if (isSharedApiContractFile(filename)) {
                         reportMissingProgramPattern(context, node, source, /\bHttpApi\.make\b/u, 'Generated shared API contracts must declare an HttpApi contract.');