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

package/dist/cjs/microvertical-api-owner.cjs

@@ -0,0 +1,217 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    baselinePackage: ()=>baselinePackage,
+    baselinePublicIdentityIsExact: ()=>baselinePublicIdentityIsExact,
+    resolveBaselinePackageDirectory: ()=>resolveBaselinePackageDirectory
+});
+const external_node_fs_namespaceObject = require("node:fs");
+var external_node_fs_default = /*#__PURE__*/ __webpack_require__.n(external_node_fs_namespaceObject);
+const external_node_module_namespaceObject = require("node:module");
+const external_node_path_namespaceObject = require("node:path");
+var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
+const parser_namespaceObject = require("@babel/parser");
+const types_namespaceObject = require("@babel/types");
+const baselinePackage = '@modern-js/bff-effect/microvertical-api';
+const ownerName = '@modern-js/bff-effect';
+const within = (root, file)=>file.startsWith(`${root}${external_node_path_default().sep}`);
+function resolveBaselinePackageDirectory(fromFile) {
+    const lookup = (0, external_node_module_namespaceObject.createRequire)(fromFile).resolve.paths(baselinePackage);
+    for (const directory of lookup ?? []){
+        const candidate = external_node_path_default().join(directory, ownerName);
+        if (!external_node_fs_default().existsSync(candidate)) continue;
+        const root = external_node_fs_default().realpathSync(candidate);
+        const manifest = JSON.parse(external_node_fs_default().readFileSync(external_node_path_default().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`);
+        external_node_fs_default().statSync(external_node_path_default().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 = external_node_fs_default().realpathSync(expectation.baselinePackageDirectory);
+    const manifest = JSON.parse(external_node_fs_default().readFileSync(external_node_path_default().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 = external_node_fs_default().realpathSync(filename);
+        if (!within(owner, real)) return;
+        let file = modules.get(real);
+        if (!file) {
+            if (modules.size >= 64 || external_node_fs_default().statSync(real).size > 1000000) throw new Error(`${real}: public export analysis budget exceeded`);
+            file = (0, parser_namespaceObject.parse)(external_node_fs_default().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 = external_node_path_default().resolve(external_node_path_default().dirname(from), specifier);
+        if (!within(owner, candidate)) return;
+        return [
+            candidate,
+            `${candidate}.ts`,
+            `${candidate}.js`,
+            external_node_path_default().join(candidate, 'index.ts'),
+            external_node_path_default().join(candidate, 'index.js')
+        ].find((file)=>external_node_fs_default().existsSync(file) && external_node_fs_default().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 (types_namespaceObject.isExportAllDeclaration(statement) && 'type' !== statement.exportKind) {
+                const next = follow(real, statement.source.value);
+                if (!next) return;
+                stars.push(next);
+            }
+            if (!types_namespaceObject.isExportNamedDeclaration(statement) || 'type' === statement.exportKind) continue;
+            const declaration = statement.declaration;
+            if (types_namespaceObject.isVariableDeclaration(declaration) && declaration.declarations.some((value)=>types_namespaceObject.isIdentifier(value.id, {
+                    name
+                }))) explicit.push(real);
+            if ((types_namespaceObject.isFunctionDeclaration(declaration) || types_namespaceObject.isClassDeclaration(declaration)) && types_namespaceObject.isIdentifier(declaration.id, {
+                name
+            })) explicit.push(real);
+            for (const value of statement.specifiers)if (types_namespaceObject.isExportSpecifier(value) && 'type' !== value.exportKind && types_namespaceObject.isIdentifier(value.exported, {
+                name
+            })) {
+                if (!types_namespaceObject.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)=>types_namespaceObject.isVariableDeclaration(item) && item.declarations.some((value)=>types_namespaceObject.isIdentifier(value.id, {
+                                name
+                            })) || (types_namespaceObject.isFunctionDeclaration(item) || types_namespaceObject.isClassDeclaration(item)) && types_namespaceObject.isIdentifier(item.id, {
+                            name
+                        }));
+                    if (local) {
+                        explicit.push(real);
+                        continue;
+                    }
+                    const imported = file.program.body.find((item)=>types_namespaceObject.isImportDeclaration(item) && 'type' !== item.importKind && item.specifiers.some((value)=>types_namespaceObject.isImportSpecifier(value) && 'type' !== value.importKind && types_namespaceObject.isIdentifier(value.local, {
+                                name
+                            }) && types_namespaceObject.isIdentifier(value.imported, {
+                                name
+                            })));
+                    const next = types_namespaceObject.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 = external_node_path_default().resolve(owner, target);
+    const owners = [
+        'MicroVerticalBuildMarkerSchema',
+        'MicroVerticalReadinessSchema',
+        'createMicroVerticalOperationContext'
+    ].map((name)=>exportedOwner(entry, name));
+    return void 0 !== owners[0] && owners.every((value)=>value === owners[0]);
+}
+exports.baselinePackage = __webpack_exports__.baselinePackage;
+exports.baselinePublicIdentityIsExact = __webpack_exports__.baselinePublicIdentityIsExact;
+exports.resolveBaselinePackageDirectory = __webpack_exports__.resolveBaselinePackageDirectory;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "baselinePackage",
+    "baselinePublicIdentityIsExact",
+    "resolveBaselinePackageDirectory"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/module-graph.cjs

@@ -0,0 +1,321 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    createModuleGraph: ()=>createModuleGraph,
+    exportedConst: ()=>exportedConst,
+    localConst: ()=>localConst,
+    parseConsumer: ()=>parseConsumer,
+    propertyName: ()=>propertyName
+});
+const external_node_fs_namespaceObject = require("node:fs");
+var external_node_fs_default = /*#__PURE__*/ __webpack_require__.n(external_node_fs_namespaceObject);
+const external_node_module_namespaceObject = require("node:module");
+const external_node_path_namespaceObject = require("node:path");
+var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
+const types_namespaceObject = require("@babel/types");
+const external_resolve_exports_namespaceObject = require("resolve.exports");
+const external_source_analysis_cjs_namespaceObject = require("./source-analysis.cjs");
+const MAX_MODULES = 256;
+const MAX_LOOKUPS = 512;
+function parseConsumer(filePath) {
+    if (external_node_fs_default().statSync(filePath).size > 1000000) throw new Error(`${filePath}: consumer source exceeds 1 MB analysis budget`);
+    const file = (0, external_source_analysis_cjs_namespaceObject.parseSource)(external_node_fs_default().readFileSync(filePath, 'utf8'), filePath);
+    (0, external_source_analysis_cjs_namespaceObject.traverseSource)(file, {
+        AssignmentExpression (p) {
+            throw new external_source_analysis_cjs_namespaceObject.SourceSyntaxError(`contract bindings must be immutable at ${p.node.start}`);
+        },
+        UpdateExpression (p) {
+            throw new external_source_analysis_cjs_namespaceObject.SourceSyntaxError(`contract bindings must be immutable at ${p.node.start}`);
+        },
+        TSModuleDeclaration () {
+            throw new external_source_analysis_cjs_namespaceObject.SourceSyntaxError('contract bindings must not be merged with namespaces');
+        }
+    });
+    return file;
+}
+const propertyName = (node)=>{
+    if (void 0 !== node && (types_namespaceObject.isIdentifier(node) || types_namespaceObject.isStringLiteral(node) || types_namespaceObject.isNumericLiteral(node))) return types_namespaceObject.isIdentifier(node) ? node.name : String(node.value);
+};
+const localConst = (sourceFile, name)=>{
+    for (const item of sourceFile.program.body){
+        const statement = types_namespaceObject.isExportNamedDeclaration(item) ? item.declaration : item;
+        if (!types_namespaceObject.isVariableDeclaration(statement) || 'const' !== statement.kind) continue;
+        const matches = statement.declarations.filter((declaration)=>types_namespaceObject.isIdentifier(declaration.id, {
+                name
+            }));
+        if (1 === matches.length) return matches[0];
+    }
+};
+const exportedConst = (sourceFile, name)=>{
+    for (const statement of sourceFile.program.body)if (types_namespaceObject.isExportNamedDeclaration(statement) && 'type' !== statement.exportKind) {
+        if (types_namespaceObject.isVariableDeclaration(statement.declaration) && 'const' === statement.declaration.kind) {
+            const declaration = statement.declaration.declarations.find((value)=>types_namespaceObject.isIdentifier(value.id, {
+                    name
+                }));
+            if (declaration) return declaration;
+        }
+        if (!statement.source && statement.specifiers.some((value)=>types_namespaceObject.isExportSpecifier(value) && 'type' !== value.exportKind && types_namespaceObject.isIdentifier(value.local, {
+                name
+            }) && types_namespaceObject.isIdentifier(value.exported, {
+                name
+            }))) return localConst(sourceFile, name);
+    }
+};
+const inside = (file, boundary)=>file === boundary || file.startsWith(`${boundary}${external_node_path_default().sep}`);
+const containingWorkspace = (file)=>{
+    for(let directory = external_node_path_default().dirname(file);; directory = external_node_path_default().dirname(directory)){
+        if (external_node_fs_default().existsSync(external_node_path_default().join(directory, 'pnpm-workspace.yaml'))) return external_node_fs_default().realpathSync(directory);
+        if (directory === external_node_path_default().dirname(directory)) return;
+    }
+};
+const sourceBoundary = (file, workspace)=>{
+    for(let directory = external_node_path_default().dirname(file);; directory = external_node_path_default().dirname(directory)){
+        if (external_node_fs_default().existsSync(external_node_path_default().join(directory, 'package.json')) && directory !== workspace) return external_node_fs_default().realpathSync(directory);
+        if (directory === workspace || directory === external_node_path_default().dirname(directory)) return external_node_fs_default().realpathSync(external_node_path_default().dirname(file));
+    }
+};
+const sourceFileAt = (target, boundary)=>{
+    const stem = target.replace(/\.(?:[cm]?[jt]sx?)$/u, '');
+    for (const candidate of [
+        `${stem}.ts`,
+        `${stem}.tsx`,
+        `${stem}.mts`,
+        `${stem}.cts`,
+        target,
+        external_node_path_default().join(target, 'index.ts'),
+        external_node_path_default().join(target, 'index.tsx')
+    ])try {
+        const real = external_node_fs_default().realpathSync(candidate);
+        if (inside(real, boundary) && external_node_fs_default().statSync(real).isFile()) return real;
+    } catch  {}
+};
+const packageEntry = (specifier)=>{
+    if (specifier.startsWith('.') || specifier.startsWith('/') || specifier.startsWith('#')) return;
+    const parts = specifier.split('/');
+    const count = specifier.startsWith('@') ? 2 : 1;
+    if (parts.length < count || parts.slice(0, count).some((part)=>!part)) return;
+    return {
+        name: parts.slice(0, count).join('/'),
+        exportKey: parts.length === count ? '.' : `./${parts.slice(count).join('/')}`
+    };
+};
+const resolveModulePath = (module, specifier, workspace)=>{
+    if (/^\.\.?\//u.test(specifier)) {
+        const file = sourceFileAt(external_node_path_default().resolve(external_node_path_default().dirname(module.path), specifier), module.boundary);
+        return void 0 === file ? void 0 : {
+            kind: 'module',
+            path: file,
+            boundary: module.boundary
+        };
+    }
+    const entry = packageEntry(specifier);
+    if (!entry) return;
+    if (!workspace) return {
+        kind: 'external'
+    };
+    const paths = (0, external_node_module_namespaceObject.createRequire)(module.path).resolve.paths(entry.name) ?? [];
+    for (const lookup of paths){
+        const directory = external_node_path_default().join(lookup, entry.name);
+        const manifest = external_node_path_default().join(directory, 'package.json');
+        if (!external_node_fs_default().existsSync(manifest)) continue;
+        const boundary = external_node_fs_default().realpathSync(directory);
+        if (!inside(boundary, workspace) || boundary.split(external_node_path_default().sep).includes('node_modules')) break;
+        const pkg = JSON.parse(external_node_fs_default().readFileSync(manifest, 'utf8'));
+        if (pkg.name !== entry.name || void 0 === pkg.exports) return;
+        let target;
+        try {
+            const targets = (0, external_resolve_exports_namespaceObject.exports)(pkg, entry.exportKey, {
+                conditions: [
+                    'modern:source'
+                ]
+            });
+            target = Array.isArray(targets) ? targets[0] : void 0;
+        } catch  {
+            return;
+        }
+        if (!target || !target.startsWith('./')) return;
+        const file = sourceFileAt(external_node_path_default().resolve(boundary, target), boundary);
+        return void 0 === file ? void 0 : {
+            kind: 'module',
+            path: file,
+            boundary
+        };
+    }
+    return {
+        kind: 'external'
+    };
+};
+const importedBinding = (module, name)=>{
+    for (const statement of module.file.program.body)if (types_namespaceObject.isImportDeclaration(statement) && 'type' !== statement.importKind) {
+        for (const specifier of statement.specifiers)if (types_namespaceObject.isIdentifier(specifier.local, {
+            name
+        })) {
+            if (types_namespaceObject.isImportSpecifier(specifier) && 'type' !== specifier.importKind) return {
+                imported: propertyName(specifier.imported) ?? name,
+                specifier: statement.source.value
+            };
+            if (types_namespaceObject.isImportDefaultSpecifier(specifier)) return {
+                imported: 'default',
+                specifier: statement.source.value
+            };
+        }
+    }
+};
+const reexportedBinding = (module, name)=>{
+    for (const statement of module.file.program.body){
+        if (!types_namespaceObject.isExportNamedDeclaration(statement) || 'type' === statement.exportKind) continue;
+        const specifier = statement.specifiers.find((value)=>types_namespaceObject.isExportSpecifier(value) && 'type' !== value.exportKind && propertyName(value.exported) === name);
+        if (void 0 !== specifier && types_namespaceObject.isExportSpecifier(specifier)) return {
+            local: types_namespaceObject.isIdentifier(specifier.local) ? specifier.local.name : specifier.local.value,
+            ...statement.source ? {
+                specifier: statement.source.value
+            } : {}
+        };
+    }
+};
+const defaultExport = (module)=>{
+    for (const statement of module.file.program.body){
+        if (!types_namespaceObject.isExportDefaultDeclaration(statement)) continue;
+        const declaration = statement.declaration;
+        if (types_namespaceObject.isIdentifier(declaration)) return declaration.name;
+        return types_namespaceObject.isExpression(declaration) ? declaration : void 0;
+    }
+};
+function createModuleGraph(filePath) {
+    const realPath = external_node_fs_default().realpathSync(filePath);
+    const workspace = containingWorkspace(realPath);
+    const root = {
+        file: parseConsumer(realPath),
+        path: realPath,
+        boundary: sourceBoundary(realPath, workspace)
+    };
+    const modules = new Map([
+        [
+            root.path,
+            root
+        ]
+    ]);
+    const readModule = (modulePath, boundary)=>{
+        if (modules.has(modulePath)) return modules.get(modulePath);
+        if (modules.size >= MAX_MODULES) return;
+        let module;
+        try {
+            module = {
+                file: parseConsumer(modulePath),
+                path: modulePath,
+                boundary
+            };
+        } catch  {
+            module = void 0;
+        }
+        modules.set(modulePath, module);
+        return module;
+    };
+    const resolveBinding = (module, name, scope, chain, seen)=>{
+        const key = `${scope}:${module.path}#${name}`;
+        if (seen.has(key) || seen.size >= MAX_LOOKUPS) return;
+        seen.add(key);
+        const last = chain.at(-1);
+        const hops = last?.path === module.path && last.name === name ? chain : [
+            ...chain,
+            {
+                path: module.path,
+                name
+            }
+        ];
+        const declaration = 'export' === scope ? exportedConst(module.file, name) : localConst(module.file, name);
+        if (declaration?.init) return {
+            kind: 'declaration',
+            expression: declaration.init,
+            module,
+            chain: hops
+        };
+        const throughModule = (specifier, imported, allowExternal)=>{
+            const target = resolveModulePath(module, specifier, workspace);
+            if (target?.kind === 'external') return allowExternal ? {
+                kind: 'external',
+                specifier,
+                name: imported,
+                chain: hops
+            } : void 0;
+            const next = target && readModule(target.path, target.boundary);
+            return void 0 === next ? void 0 : resolveBinding(next, imported, 'export', hops, seen);
+        };
+        if ('local' === scope) {
+            const imported = importedBinding(module, name);
+            return void 0 === imported ? void 0 : throughModule(imported.specifier, imported.imported, true);
+        }
+        if ('default' === name) {
+            const exported = defaultExport(module);
+            if ('string' == typeof exported) return resolveBinding(module, exported, 'local', hops, seen);
+            return void 0 === exported ? void 0 : {
+                kind: 'declaration',
+                expression: exported,
+                module,
+                chain: hops
+            };
+        }
+        const reexported = reexportedBinding(module, name);
+        if (void 0 !== reexported) return void 0 === reexported.specifier ? resolveBinding(module, reexported.local, 'local', hops, seen) : throughModule(reexported.specifier, reexported.local, true);
+        for (const statement of module.file.program.body){
+            if (!types_namespaceObject.isExportAllDeclaration(statement) || 'type' === statement.exportKind) continue;
+            const resolved = throughModule(statement.source.value, name, false);
+            if (void 0 !== resolved) return resolved;
+        }
+    };
+    return {
+        root,
+        resolve: (module, name, scope)=>resolveBinding(module, name, scope, [], new Set())
+    };
+}
+exports.createModuleGraph = __webpack_exports__.createModuleGraph;
+exports.exportedConst = __webpack_exports__.exportedConst;
+exports.localConst = __webpack_exports__.localConst;
+exports.parseConsumer = __webpack_exports__.parseConsumer;
+exports.propertyName = __webpack_exports__.propertyName;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createModuleGraph",
+    "exportedConst",
+    "localConst",
+    "parseConsumer",
+    "propertyName"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/oxlint-plugin/rules/strict-effect-api-boundaries.cjs

@@ -30,6 +30,7 @@ __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
     createStrictEffectApiBoundariesRule: ()=>createStrictEffectApiBoundariesRule
 });
+const external_strict_effect_runtime_cjs_namespaceObject = require("../../strict-effect-runtime.cjs");
 const external_ast_cjs_namespaceObject = require("../ast.cjs");
 const createStrictEffectApiBoundariesRule = ()=>({
         meta: {
@@ -49,15 +50,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.'
                     });
-                    (0, external_ast_cjs_namespaceObject.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.');
+                    (0, external_ast_cjs_namespaceObject.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.');
                     (0, external_ast_cjs_namespaceObject.reportProgramPattern)(context, node, source, /\bruntimeFramework\s*(?::|=)\s*['"]hono['"]/u, 'UltraModern API apps must use bff.runtimeFramework: "effect".');
-                    (0, external_ast_cjs_namespaceObject.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.');
+                    (0, external_ast_cjs_namespaceObject.reportProgramPattern)(context, node, source, /(?:from|import)\s*['"][^'"]*(?:api\/effect|shared\/effect)(?=\/|\.[cm]?[jt]sx?['"]|['"])[^'"]*['"]|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.');
                     (0, external_ast_cjs_namespaceObject.reportProgramPattern)(context, node, source, /\bstrictEffectApproach\s*(?::|=)\s*false\b/u, 'UltraModern API apps must keep strictEffectApproach enabled.');
                     if ((0, external_ast_cjs_namespaceObject.isApiEntryFile)(filename)) {
-                        (0, external_ast_cjs_namespaceObject.reportMissingProgramPattern)(context, node, source, /\bdefineEffectBff\b/u, 'Generated API entries must export defineEffectBff(...).');
-                        (0, external_ast_cjs_namespaceObject.reportMissingProgramPattern)(context, node, source, /\bHttpApiBuilder\b/u, 'Generated API entries must implement handlers through HttpApiBuilder.');
-                        (0, external_ast_cjs_namespaceObject.reportMissingProgramPattern)(context, node, source, /\bLayer\b/u, 'Generated API entries must compose dependencies with Effect Layer.');
-                        (0, external_ast_cjs_namespaceObject.reportMissingProgramPattern)(context, node, source, /from\s+['"]\.\.\/shared\/api\.ts['"]/u, 'Generated API entries must import the contract from ../shared/api.ts.');
+                        const violation = (0, external_strict_effect_runtime_cjs_namespaceObject.strictEffectRuntimeTopologyViolation)(source, (0, external_strict_effect_runtime_cjs_namespaceObject.createEffectApiImportResolver)(filename));
+                        if (violation) context.report({
+                            node,
+                            message: violation
+                        });
                     }
                     if ((0, external_ast_cjs_namespaceObject.isSharedApiContractFile)(filename)) {
                         (0, external_ast_cjs_namespaceObject.reportMissingProgramPattern)(context, node, source, /\bHttpApi\.make\b/u, 'Generated shared API contracts must declare an HttpApi contract.');

package/dist/cjs/source-analysis.cjs

@@ -0,0 +1,104 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    SourceSyntaxError: ()=>SourceSyntaxError,
+    consumerParserPlugins: ()=>consumerParserPlugins,
+    parseSource: ()=>parseSource,
+    traverseSource: ()=>traverseSource,
+    unwrapExpression: ()=>unwrapExpression
+});
+const parser_namespaceObject = require("@babel/parser");
+const traverse_namespaceObject = require("@babel/traverse");
+var traverse_default = /*#__PURE__*/ __webpack_require__.n(traverse_namespaceObject);
+const types_namespaceObject = require("@babel/types");
+const consumerParserPlugins = (filePath)=>/\.[jt]sx$/u.test(filePath) ? [
+        "typescript",
+        'jsx'
+    ] : [
+        "typescript"
+    ];
+class SourceSyntaxError extends Error {
+}
+class SourceValidationHub extends traverse_namespaceObject.Hub {
+    buildError(_node, message) {
+        return new SourceSyntaxError(message);
+    }
+}
+function parseSource(source, filename, syntaxMessage) {
+    try {
+        return (0, parser_namespaceObject.parse)(source, {
+            sourceType: 'module',
+            sourceFilename: filename,
+            plugins: consumerParserPlugins(filename)
+        });
+    } catch (cause) {
+        if ('object' == typeof cause && null !== cause && 'code' in cause && 'BABEL_PARSER_SYNTAX_ERROR' === cause.code && 'reasonCode' in cause && 'string' == typeof cause.reasonCode) throw new SourceSyntaxError(syntaxMessage ?? (cause instanceof Error ? cause.message : String(cause)));
+        throw cause;
+    }
+}
+function traverseSource(file, visitor) {
+    const program = traverse_namespaceObject.NodePath.get({
+        hub: new SourceValidationHub(),
+        parentPath: void 0,
+        parent: file,
+        container: file,
+        key: 'program'
+    });
+    program.setContext();
+    traverse_default()(file, visitor, program.scope, void 0, program);
+}
+function unwrapExpression(node, includeAssertions = false) {
+    while(types_namespaceObject.isTSAsExpression(node) || types_namespaceObject.isParenthesizedExpression(node) || types_namespaceObject.isTSSatisfiesExpression(node) || includeAssertions && (types_namespaceObject.isTSTypeAssertion(node) || types_namespaceObject.isTSNonNullExpression(node)))node = node.expression;
+    return node;
+}
+exports.SourceSyntaxError = __webpack_exports__.SourceSyntaxError;
+exports.consumerParserPlugins = __webpack_exports__.consumerParserPlugins;
+exports.parseSource = __webpack_exports__.parseSource;
+exports.traverseSource = __webpack_exports__.traverseSource;
+exports.unwrapExpression = __webpack_exports__.unwrapExpression;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "SourceSyntaxError",
+    "consumerParserPlugins",
+    "parseSource",
+    "traverseSource",
+    "unwrapExpression"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});