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

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/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, /\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/strict-effect-runtime.cjs

@@ -0,0 +1,411 @@
+"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__, {
+    createEffectApiImportResolver: ()=>createEffectApiImportResolver,
+    strictEffectRuntimeTopologyViolation: ()=>strictEffectRuntimeTopologyViolation
+});
+const external_node_fs_namespaceObject = require("node:fs");
+var external_node_fs_default = /*#__PURE__*/ __webpack_require__.n(external_node_fs_namespaceObject);
+const external_node_path_namespaceObject = require("node:path");
+var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
+const 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 edge = '@modern-js/bff-effect/effect-edge';
+const nodeRuntime = '@modern-js/bff-effect/effect';
+const sharedRuntime = /^@[^/]+\/shared-contracts\/server\/effect-bff-runtime$/u;
+const failure = 'Generated API entries must export defineEffectBff(...) or the server-only shared Effect BFF assembly helper with an explicitly composed handler Layer and an unshadowed executable root; entries must implement handlers through HttpApiBuilder.group.';
+const invalidSources = new WeakSet();
+function invalidSource(message) {
+    const error = new Error(message);
+    invalidSources.add(error);
+    return error;
+}
+class SourceValidationHub extends traverse_namespaceObject.Hub {
+    buildError(_node, message) {
+        return invalidSource(message);
+    }
+}
+function createEffectApiImportResolver(filename) {
+    const directory = external_node_fs_default().realpathSync(external_node_path_default().dirname(filename));
+    const owner = external_node_fs_default().realpathSync(external_node_path_default().resolve(directory, '..'));
+    const resolve = (from)=>(specifier)=>{
+            if (!specifier.startsWith('.')) return;
+            const target = external_node_path_default().resolve(external_node_path_default().dirname(from), specifier);
+            if (!target.startsWith(`${owner}${external_node_path_default().sep}`)) return;
+            for (const candidate of [
+                target,
+                `${target}.ts`,
+                `${target}.mts`
+            ])try {
+                const real = external_node_fs_default().realpathSync(candidate);
+                if (!real.startsWith(`${owner}${external_node_path_default().sep}`) || external_node_fs_default().statSync(real).size > 1000000) return;
+                return {
+                    id: real,
+                    source: external_node_fs_default().readFileSync(real, 'utf8'),
+                    resolveImport: resolve(real)
+                };
+            } catch  {}
+        };
+    return resolve(external_node_path_default().join(directory, external_node_path_default().basename(filename)));
+}
+function strictEffectRuntimeTopologyViolation(source, resolveImport) {
+    const modules = new Map();
+    const owners = new Map();
+    const paths = new Map();
+    const mutated = new Set();
+    const load = (input)=>{
+        const existing = modules.get(input.id);
+        if (existing) return existing;
+        if (modules.size >= 64 || input.source.length > 1000000) throw invalidSource('API source budget exceeded');
+        let file;
+        try {
+            file = (0, parser_namespaceObject.parse)(input.source, {
+                sourceType: 'module',
+                sourceFilename: input.id,
+                plugins: [
+                    "typescript"
+                ]
+            });
+        } 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 invalidSource('Invalid API syntax');
+            throw cause;
+        }
+        const module = {
+            ...input,
+            file
+        };
+        modules.set(input.id, module);
+        const program = traverse_namespaceObject.NodePath.get({
+            hub: new SourceValidationHub(),
+            parentPath: void 0,
+            parent: file,
+            container: file,
+            key: 'program'
+        });
+        program.setContext();
+        traverse_default()(file, {
+            enter (nodePath) {
+                paths.set(nodePath.node, nodePath);
+                owners.set(nodePath.node, module);
+                if (nodePath.isAssignmentExpression() || nodePath.isUpdateExpression() || nodePath.isUnaryExpression({
+                    operator: 'delete'
+                })) {
+                    let target = nodePath.isAssignmentExpression() ? nodePath.node.left : nodePath.node.argument;
+                    while(types_namespaceObject.isMemberExpression(target))target = target.object;
+                    if (types_namespaceObject.isIdentifier(target)) {
+                        const binding = nodePath.scope.getBinding(target.name);
+                        if (binding) mutated.add(binding);
+                    }
+                }
+                if (nodePath.isTSModuleDeclaration() && types_namespaceObject.isIdentifier(nodePath.node.id)) {
+                    const binding = nodePath.scope.getBinding(nodePath.node.id.name);
+                    if (binding) mutated.add(binding);
+                }
+            }
+        }, program.scope, void 0, program);
+        return module;
+    };
+    try {
+        const entry = load({
+            id: '/entry.ts',
+            source,
+            resolveImport
+        });
+        const unwrap = (node)=>{
+            while(types_namespaceObject.isParenthesizedExpression(node) || types_namespaceObject.isTSSatisfiesExpression(node) || types_namespaceObject.isTSAsExpression(node) || types_namespaceObject.isTSTypeAssertion(node) || types_namespaceObject.isTSNonNullExpression(node))node = node.expression;
+            return node;
+        };
+        const binding = (node)=>{
+            node = unwrap(node);
+            if (!types_namespaceObject.isIdentifier(node)) return;
+            const nodePath = paths.get(node);
+            if (!nodePath) throw new Error('Missing API lexical scope');
+            const value = nodePath.scope.getBinding(node.name);
+            return value?.constant && !mutated.has(value) ? value : void 0;
+        };
+        const declaration = (node)=>binding(node)?.path.node;
+        const imported = (node)=>{
+            const value = binding(node);
+            const decl = value?.path.node;
+            if (!decl || !types_namespaceObject.isImportSpecifier(decl) && !types_namespaceObject.isImportNamespaceSpecifier(decl) || types_namespaceObject.isImportSpecifier(decl) && 'type' === decl.importKind) return;
+            const statement = value.path.parent;
+            if (!types_namespaceObject.isImportDeclaration(statement) || 'type' === statement.importKind) return;
+            return {
+                namespace: types_namespaceObject.isImportNamespaceSpecifier(decl),
+                name: types_namespaceObject.isImportNamespaceSpecifier(decl) ? '*' : types_namespaceObject.isIdentifier(decl.imported) ? decl.imported.name : decl.imported.value,
+                specifier: statement.source.value
+            };
+        };
+        const namespaceSources = {
+            HttpApi: [
+                edge,
+                'effect/unstable/httpapi'
+            ],
+            HttpApiBuilder: [
+                edge,
+                'effect/unstable/httpapi'
+            ],
+            HttpRouter: [
+                edge,
+                'effect/unstable/http'
+            ]
+        };
+        const native = (node, name, sources)=>{
+            const value = imported(node);
+            if (!value) return false;
+            const importedNameMatches = value.namespace ? value.specifier === `effect/${name}` : value.name === name && value.specifier !== `effect/${name}`;
+            return importedNameMatches && (sources ?? namespaceSources[name] ?? [
+                edge
+            ]).includes(value.specifier);
+        };
+        const method = (node, namespace, member, sources)=>{
+            node = unwrap(node);
+            return types_namespaceObject.isMemberExpression(node) && !node.computed && types_namespaceObject.isIdentifier(node.property, {
+                name: member
+            }) && native(node.object, namespace, sources);
+        };
+        const initialized = (node)=>{
+            const value = binding(node);
+            return value?.kind === 'const' && types_namespaceObject.isVariableDeclarator(value.path.node) ? value.path.node.init ?? void 0 : void 0;
+        };
+        const moduleFor = (node)=>{
+            const value = imported(node);
+            if (!value) return;
+            const input = owners.get(node)?.resolveImport?.(value.specifier);
+            return input ? {
+                module: load(input),
+                name: value.name
+            } : void 0;
+        };
+        const exported = (module, name)=>{
+            for (const statement of module.file.program.body)if (types_namespaceObject.isExportNamedDeclaration(statement) && 'type' !== statement.exportKind) {
+                if (types_namespaceObject.isVariableDeclaration(statement.declaration)) {
+                    for (const decl of statement.declaration.declarations)if (types_namespaceObject.isIdentifier(decl.id, {
+                        name
+                    })) return decl.id;
+                }
+                if (!statement.source) {
+                    const specifier = statement.specifiers.find((element)=>types_namespaceObject.isExportSpecifier(element) && 'type' !== element.exportKind && (types_namespaceObject.isIdentifier(element.exported) ? element.exported.name : element.exported.value) === name);
+                    if (types_namespaceObject.isExportSpecifier(specifier)) return specifier.local;
+                }
+            }
+        };
+        const externalValue = (node)=>{
+            const value = moduleFor(node);
+            return value ? exported(value.module, value.name) : void 0;
+        };
+        const apiIdentity = (node, seen = new Set())=>{
+            node = unwrap(node);
+            if (seen.has(node)) return;
+            seen.add(node);
+            const value = imported(node);
+            if (value) {
+                if (!value.specifier.startsWith('.')) return;
+                const module = moduleFor(node);
+                const exportedValue = module && exported(module.module, module.name);
+                if (exportedValue) return apiIdentity(exportedValue, seen);
+                if (module && /(?:^|\/)shared\/(?:api|rpc)\.ts$/u.test(value.specifier)) return `${module.module.id}:import:${value.name}`;
+                if (!owners.get(node)?.resolveImport && /(?:^|\/)shared\/(?:api|rpc)\.ts$/u.test(value.specifier)) return `${value.specifier}:${value.name}`;
+                return;
+            }
+            const init = initialized(node);
+            if (init && types_namespaceObject.isIdentifier(unwrap(init))) return apiIdentity(init, seen);
+            const valueBinding = binding(node);
+            return valueBinding ? `${owners.get(valueBinding.path.node)?.id}:${valueBinding.identifier.start}` : void 0;
+        };
+        const properties = (node)=>{
+            node = unwrap(node);
+            if (!types_namespaceObject.isObjectExpression(node)) return;
+            const result = new Map();
+            for (const prop of node.properties){
+                if (!types_namespaceObject.isObjectProperty(prop) || prop.computed || !types_namespaceObject.isIdentifier(prop.key) || result.has(prop.key.name)) return;
+                result.set(prop.key.name, prop.value);
+            }
+            return result;
+        };
+        const active = new Set();
+        const guarded = (node, check)=>{
+            node = unwrap(node);
+            if (active.has(node) || active.size > 128) return false;
+            active.add(node);
+            try {
+                return check(node);
+            } finally{
+                active.delete(node);
+            }
+        };
+        const layerSources = [
+            edge,
+            'effect',
+            'effect/Layer'
+        ];
+        const returned = (body)=>{
+            if (!types_namespaceObject.isBlockStatement(body)) return body;
+            const statements = body.body;
+            const last = statements.at(-1);
+            return statements.slice(0, -1).every((statement)=>types_namespaceObject.isVariableDeclaration(statement)) && types_namespaceObject.isReturnStatement(last) ? last.argument : void 0;
+        };
+        const pipe = (node, check)=>types_namespaceObject.isMemberExpression(node.callee) && !node.callee.computed && types_namespaceObject.isIdentifier(node.callee.property, {
+                name: 'pipe'
+            }) && check(node.callee.object) && node.arguments.every((argument)=>method(argument, 'Layer', 'orDie', layerSources) || types_namespaceObject.isCallExpression(argument) && method(argument.callee, 'Layer', 'provide', layerSources) && argument.arguments.length > 0);
+        const handled = (node)=>{
+            node = unwrap(node);
+            if (!types_namespaceObject.isArrowFunctionExpression(node) && !types_namespaceObject.isFunctionExpression(node)) return false;
+            const parameter = node.params[0];
+            if (!types_namespaceObject.isIdentifier(parameter)) return false;
+            const body = returned(node.body);
+            const chain = (value, count = 0)=>{
+                value = unwrap(value);
+                if (types_namespaceObject.isIdentifier(value)) return count > 0 && declaration(value) === parameter;
+                return types_namespaceObject.isCallExpression(value) && types_namespaceObject.isMemberExpression(value.callee) && !value.callee.computed && types_namespaceObject.isIdentifier(value.callee.property) && [
+                    'handle',
+                    'handleRaw'
+                ].includes(value.callee.property.name) && 2 === value.arguments.length && chain(value.callee.object, count + 1);
+            };
+            return !!body && chain(body);
+        };
+        const handlers = (node, api)=>guarded(node, (node)=>{
+                const init = initialized(node) ?? externalValue(node);
+                if (init) return handlers(init, api);
+                if (!types_namespaceObject.isCallExpression(node)) return false;
+                if (pipe(node, (value)=>handlers(value, api))) return true;
+                if (method(node.callee, 'Layer', 'mergeAll', layerSources)) return node.arguments.length > 0 && node.arguments.every((argument)=>handlers(argument, api));
+                return method(node.callee, 'HttpApiBuilder', 'group') && 3 === node.arguments.length && apiIdentity(node.arguments[0]) === api && handled(node.arguments[2]);
+            });
+        const transport = (node)=>guarded(node, (node)=>{
+                const init = initialized(node);
+                if (init) return transport(init);
+                if (!types_namespaceObject.isCallExpression(node)) return method(node, 'Layer', 'empty', layerSources);
+                return pipe(node, transport) || method(node.callee, 'HttpRouter', 'cors') || method(node.callee, 'Layer', 'mergeAll', layerSources) && node.arguments.length > 0 && node.arguments.every(transport);
+            });
+        const directLayer = (node, api)=>guarded(node, (node)=>{
+                const init = initialized(node);
+                if (init) return directLayer(init, api);
+                if (!types_namespaceObject.isCallExpression(node) || !types_namespaceObject.isMemberExpression(node.callee) || node.callee.computed || !types_namespaceObject.isIdentifier(node.callee.property, {
+                    name: 'pipe'
+                })) return false;
+                const base = unwrap(node.callee.object);
+                return types_namespaceObject.isCallExpression(base) && method(base.callee, 'HttpApiBuilder', 'layer') && 1 === base.arguments.length && apiIdentity(base.arguments[0]) === api && node.arguments.length > 0 && node.arguments.every((argument)=>types_namespaceObject.isCallExpression(argument) && method(argument.callee, 'Layer', 'provide', layerSources) && 1 === argument.arguments.length && handlers(argument.arguments[0], api));
+            });
+        const rpc = (values)=>{
+            const api = values.get('api');
+            const apiLayer = values.get('layer');
+            const apiInit = api && (initialized(api) ?? unwrap(api));
+            if (!apiInit || !types_namespaceObject.isCallExpression(apiInit) || !method(apiInit.callee, 'HttpApi', 'make') || 1 !== apiInit.arguments.length || !apiLayer || !transport(apiLayer)) return false;
+            const config = values.get('rpc');
+            const fields = config && properties(config);
+            const route = fields?.get('path');
+            const serialization = fields?.get('serialization');
+            if (!types_namespaceObject.isStringLiteral(route, {
+                value: '/rpc'
+            }) || !types_namespaceObject.isStringLiteral(serialization, {
+                value: 'json'
+            })) return false;
+            const group = fields?.get('group');
+            const layer = fields?.get('layer');
+            const value = group && imported(group);
+            if (!group || !layer || value?.specifier !== '../shared/rpc.ts') return false;
+            const groupValue = externalValue(group);
+            const groupInit = groupValue && initialized(groupValue);
+            if (!groupInit || !types_namespaceObject.isCallExpression(groupInit) || !method(groupInit.callee, 'RpcGroup', 'make', [
+                'effect/unstable/rpc',
+                '@modern-js/bff-effect/effect-client'
+            ])) return false;
+            const layerInit = initialized(layer) ?? unwrap(layer);
+            if (!types_namespaceObject.isCallExpression(layerInit) || !types_namespaceObject.isMemberExpression(layerInit.callee) || layerInit.callee.computed || !types_namespaceObject.isIdentifier(layerInit.callee.property, {
+                name: 'toLayer'
+            }) || apiIdentity(layerInit.callee.object) !== apiIdentity(group) || 1 !== layerInit.arguments.length) return false;
+            const implementation = unwrap(layerInit.arguments[0]);
+            if (!types_namespaceObject.isCallExpression(implementation) || !types_namespaceObject.isMemberExpression(implementation.callee) || implementation.callee.computed || !types_namespaceObject.isIdentifier(implementation.callee.property, {
+                name: 'of'
+            }) || apiIdentity(implementation.callee.object) !== apiIdentity(group) || 1 !== implementation.arguments.length) return false;
+            const entries = properties(implementation.arguments[0]);
+            return !!entries?.size && [
+                ...entries.values()
+            ].every((value)=>types_namespaceObject.isArrowFunctionExpression(value) || types_namespaceObject.isFunctionExpression(value));
+        };
+        const runtime = (node)=>guarded(node, (node)=>{
+                const init = initialized(node);
+                if (init) return runtime(init);
+                if (!types_namespaceObject.isCallExpression(node)) return false;
+                const value = imported(node.callee);
+                if (value?.name === 'defineEffectBff' && [
+                    edge,
+                    nodeRuntime
+                ].includes(value.specifier) || value?.name === 'assembleEffectBffRuntime' && sharedRuntime.test(value.specifier)) {
+                    if (1 !== node.arguments.length) return false;
+                    const values = properties(node.arguments[0]);
+                    if (!values) return false;
+                    if ('defineEffectBff' === value.name && values.has('rpc')) return rpc(values);
+                    const api = values.get('api');
+                    const apiBinding = api && imported(api);
+                    if (!api || apiBinding?.specifier !== '../shared/api.ts') return false;
+                    const identity = apiIdentity(api);
+                    if (!identity) return false;
+                    const layer = values.get('defineEffectBff' === value.name ? 'layer' : 'handlers');
+                    const extra = values.get('transport');
+                    return void 0 !== layer && ('defineEffectBff' === value.name ? directLayer(layer, identity) : handlers(layer, identity)) && (!extra || transport(extra));
+                }
+                const decl = declaration(node.callee);
+                const factory = decl && types_namespaceObject.isFunctionDeclaration(decl) ? decl : initialized(node.callee);
+                if (!factory || !types_namespaceObject.isFunctionDeclaration(factory) && !types_namespaceObject.isArrowFunctionExpression(factory) && !types_namespaceObject.isFunctionExpression(factory) || !factory.body) return false;
+                const result = returned(factory.body);
+                return !!result && runtime(result);
+            });
+        const root = entry.file.program.body.find((statement)=>types_namespaceObject.isExportDefaultDeclaration(statement));
+        return root && runtime(root.declaration) ? void 0 : failure;
+    } catch (cause) {
+        if ('object' == typeof cause && null !== cause && invalidSources.has(cause)) return failure;
+        const message = 'object' == typeof cause && null !== cause && 'message' in cause && 'string' == typeof cause.message ? cause.message : String(cause);
+        throw new Error(`Strict Effect API analysis failed: ${message}`, {
+            cause
+        });
+    }
+}
+exports.createEffectApiImportResolver = __webpack_exports__.createEffectApiImportResolver;
+exports.strictEffectRuntimeTopologyViolation = __webpack_exports__.strictEffectRuntimeTopologyViolation;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createEffectApiImportResolver",
+    "strictEffectRuntimeTopologyViolation"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});