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

package/dist/cjs/cli/oxlint.cjs

@@ -121,22 +121,26 @@ const runOxlintRules = ({ cwd, targets, rules })=>{
         stdout: '',
         stderr: ''
     };
+    const pluginPath = resolvePluginPath();
     const tempDir = external_node_fs_default().mkdtempSync(external_node_path_default().join(external_node_os_default().tmpdir(), 'modern-code-tools-oxlint-'));
     const configPath = external_node_path_default().join(tempDir, 'oxlint.config.mjs');
-    const pluginPath = resolvePluginPath();
-    external_node_fs_default().writeFileSync(configPath, `export default {
-  jsPlugins: [${JSON.stringify(pluginPath)}],
+    const adapterPath = external_node_path_default().join(tempDir, 'oxlint-plugin.mjs');
+    try {
+        external_node_fs_default().writeFileSync(adapterPath, `import plugin from ${JSON.stringify((0, external_node_url_namespaceObject.pathToFileURL)(pluginPath).href)};
+export default plugin.rules ? plugin : plugin.default;
+`, 'utf-8');
+        external_node_fs_default().writeFileSync(configPath, `export default {
+  jsPlugins: [${JSON.stringify(adapterPath)}],
   rules: ${JSON.stringify(rules, null, 2)}
 };
 `, 'utf-8');
-    try {
         const result = (0, external_node_child_process_namespaceObject.spawnSync)(process.execPath, [
             resolveOxlintBin(),
             ...resolvedTargets,
             '--config',
             configPath,
             '--format',
-            'unix',
+            'default',
             '--quiet'
         ], {
             cwd,

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: {
@@ -54,10 +55,11 @@ const createStrictEffectApiBoundariesRule = ()=>({
                     (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,391 @@
+"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/plugin-bff/effect-edge';
+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) || 'type' === decl.importKind) return;
+            const statement = value.path.parent;
+            if (!types_namespaceObject.isImportDeclaration(statement) || 'type' === statement.importKind) return;
+            return {
+                name: types_namespaceObject.isIdentifier(decl.imported) ? decl.imported.name : decl.imported.value,
+                specifier: statement.source.value
+            };
+        };
+        const native = (node, name, sources = [
+            edge
+        ])=>{
+            const value = imported(node);
+            return value?.name === name && sources.includes(value.specifier);
+        };
+        const method = (node, namespace, member, sources = [
+            edge
+        ])=>{
+            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'
+        ];
+        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/plugin-bff/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' && value.specifier === edge || 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
+});

package/dist/esm/cli/oxlint.js

@@ -3,7 +3,7 @@ import node_fs from "node:fs";
 import { createRequire } from "node:module";
 import node_os from "node:os";
 import node_path from "node:path";
-import { fileURLToPath } from "node:url";
+import { fileURLToPath, pathToFileURL } from "node:url";
 const oxlint_require = createRequire(import.meta.url);
 const ignoredDirectories = new Set([
     '.modern',
@@ -73,22 +73,26 @@ const runOxlintRules = ({ cwd, targets, rules })=>{
         stdout: '',
         stderr: ''
     };
+    const pluginPath = resolvePluginPath();
     const tempDir = node_fs.mkdtempSync(node_path.join(node_os.tmpdir(), 'modern-code-tools-oxlint-'));
     const configPath = node_path.join(tempDir, 'oxlint.config.mjs');
-    const pluginPath = resolvePluginPath();
-    node_fs.writeFileSync(configPath, `export default {
-  jsPlugins: [${JSON.stringify(pluginPath)}],
+    const adapterPath = node_path.join(tempDir, 'oxlint-plugin.mjs');
+    try {
+        node_fs.writeFileSync(adapterPath, `import plugin from ${JSON.stringify(pathToFileURL(pluginPath).href)};
+export default plugin.rules ? plugin : plugin.default;
+`, 'utf-8');
+        node_fs.writeFileSync(configPath, `export default {
+  jsPlugins: [${JSON.stringify(adapterPath)}],
   rules: ${JSON.stringify(rules, null, 2)}
 };
 `, 'utf-8');
-    try {
         const result = spawnSync(process.execPath, [
             resolveOxlintBin(),
             ...resolvedTargets,
             '--config',
             configPath,
             '--format',
-            'unix',
+            'default',
             '--quiet'
         ], {
             cwd,

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

@@ -1,3 +1,4 @@
+import { createEffectApiImportResolver, strictEffectRuntimeTopologyViolation } from "../../strict-effect-runtime.js";
 import { getSourceText, isApiEntryFile, isApiSourceFile, isForbiddenGeneratedEffectPath, isSharedApiContractFile, normalizeFilename, reportMissingProgramPattern, reportProgramPattern } from "../ast.js";
 const createStrictEffectApiBoundariesRule = ()=>({
         meta: {
@@ -22,10 +23,11 @@ const createStrictEffectApiBoundariesRule = ()=>({
                     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.');