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

package/dist/esm-node/strict-effect-runtime.js

@@ -0,0 +1,335 @@
+import "node:module";
+import node_fs from "node:fs";
+import node_path from "node:path";
+import { parse } from "@babel/parser";
+import traverse, { Hub, NodePath } from "@babel/traverse";
+import * as __rspack_external__babel_types_6e8337dd from "@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 Hub {
+    buildError(_node, message) {
+        return invalidSource(message);
+    }
+}
+function createEffectApiImportResolver(filename) {
+    const directory = node_fs.realpathSync(node_path.dirname(filename));
+    const owner = node_fs.realpathSync(node_path.resolve(directory, '..'));
+    const resolve = (from)=>(specifier)=>{
+            if (!specifier.startsWith('.')) return;
+            const target = node_path.resolve(node_path.dirname(from), specifier);
+            if (!target.startsWith(`${owner}${node_path.sep}`)) return;
+            for (const candidate of [
+                target,
+                `${target}.ts`,
+                `${target}.mts`
+            ])try {
+                const real = node_fs.realpathSync(candidate);
+                if (!real.startsWith(`${owner}${node_path.sep}`) || node_fs.statSync(real).size > 1000000) return;
+                return {
+                    id: real,
+                    source: node_fs.readFileSync(real, 'utf8'),
+                    resolveImport: resolve(real)
+                };
+            } catch  {}
+        };
+    return resolve(node_path.join(directory, node_path.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 = 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 = NodePath.get({
+            hub: new SourceValidationHub(),
+            parentPath: void 0,
+            parent: file,
+            container: file,
+            key: 'program'
+        });
+        program.setContext();
+        traverse(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(__rspack_external__babel_types_6e8337dd.isMemberExpression(target))target = target.object;
+                    if (__rspack_external__babel_types_6e8337dd.isIdentifier(target)) {
+                        const binding = nodePath.scope.getBinding(target.name);
+                        if (binding) mutated.add(binding);
+                    }
+                }
+                if (nodePath.isTSModuleDeclaration() && __rspack_external__babel_types_6e8337dd.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(__rspack_external__babel_types_6e8337dd.isParenthesizedExpression(node) || __rspack_external__babel_types_6e8337dd.isTSSatisfiesExpression(node) || __rspack_external__babel_types_6e8337dd.isTSAsExpression(node) || __rspack_external__babel_types_6e8337dd.isTSTypeAssertion(node) || __rspack_external__babel_types_6e8337dd.isTSNonNullExpression(node))node = node.expression;
+            return node;
+        };
+        const binding = (node)=>{
+            node = unwrap(node);
+            if (!__rspack_external__babel_types_6e8337dd.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 || !__rspack_external__babel_types_6e8337dd.isImportSpecifier(decl) || 'type' === decl.importKind) return;
+            const statement = value.path.parent;
+            if (!__rspack_external__babel_types_6e8337dd.isImportDeclaration(statement) || 'type' === statement.importKind) return;
+            return {
+                name: __rspack_external__babel_types_6e8337dd.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 __rspack_external__babel_types_6e8337dd.isMemberExpression(node) && !node.computed && __rspack_external__babel_types_6e8337dd.isIdentifier(node.property, {
+                name: member
+            }) && native(node.object, namespace, sources);
+        };
+        const initialized = (node)=>{
+            const value = binding(node);
+            return value?.kind === 'const' && __rspack_external__babel_types_6e8337dd.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 (__rspack_external__babel_types_6e8337dd.isExportNamedDeclaration(statement) && 'type' !== statement.exportKind) {
+                if (__rspack_external__babel_types_6e8337dd.isVariableDeclaration(statement.declaration)) {
+                    for (const decl of statement.declaration.declarations)if (__rspack_external__babel_types_6e8337dd.isIdentifier(decl.id, {
+                        name
+                    })) return decl.id;
+                }
+                if (!statement.source) {
+                    const specifier = statement.specifiers.find((element)=>__rspack_external__babel_types_6e8337dd.isExportSpecifier(element) && 'type' !== element.exportKind && (__rspack_external__babel_types_6e8337dd.isIdentifier(element.exported) ? element.exported.name : element.exported.value) === name);
+                    if (__rspack_external__babel_types_6e8337dd.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 && __rspack_external__babel_types_6e8337dd.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 (!__rspack_external__babel_types_6e8337dd.isObjectExpression(node)) return;
+            const result = new Map();
+            for (const prop of node.properties){
+                if (!__rspack_external__babel_types_6e8337dd.isObjectProperty(prop) || prop.computed || !__rspack_external__babel_types_6e8337dd.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 pipe = (node, check)=>__rspack_external__babel_types_6e8337dd.isMemberExpression(node.callee) && !node.callee.computed && __rspack_external__babel_types_6e8337dd.isIdentifier(node.callee.property, {
+                name: 'pipe'
+            }) && check(node.callee.object) && node.arguments.every((argument)=>method(argument, 'Layer', 'orDie', layerSources) || __rspack_external__babel_types_6e8337dd.isCallExpression(argument) && method(argument.callee, 'Layer', 'provide', layerSources) && argument.arguments.length > 0);
+        const handled = (node)=>{
+            node = unwrap(node);
+            if (!__rspack_external__babel_types_6e8337dd.isArrowFunctionExpression(node) && !__rspack_external__babel_types_6e8337dd.isFunctionExpression(node)) return false;
+            const parameter = node.params[0];
+            if (!__rspack_external__babel_types_6e8337dd.isIdentifier(parameter)) return false;
+            const body = __rspack_external__babel_types_6e8337dd.isBlockStatement(node.body) ? 1 === node.body.body.length && __rspack_external__babel_types_6e8337dd.isReturnStatement(node.body.body[0]) ? node.body.body[0].argument : void 0 : node.body;
+            const chain = (value, count = 0)=>{
+                value = unwrap(value);
+                if (__rspack_external__babel_types_6e8337dd.isIdentifier(value)) return count > 0 && declaration(value) === parameter;
+                return __rspack_external__babel_types_6e8337dd.isCallExpression(value) && __rspack_external__babel_types_6e8337dd.isMemberExpression(value.callee) && !value.callee.computed && __rspack_external__babel_types_6e8337dd.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 (!__rspack_external__babel_types_6e8337dd.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 (!__rspack_external__babel_types_6e8337dd.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 (!__rspack_external__babel_types_6e8337dd.isCallExpression(node) || !__rspack_external__babel_types_6e8337dd.isMemberExpression(node.callee) || node.callee.computed || !__rspack_external__babel_types_6e8337dd.isIdentifier(node.callee.property, {
+                    name: 'pipe'
+                })) return false;
+                const base = unwrap(node.callee.object);
+                return __rspack_external__babel_types_6e8337dd.isCallExpression(base) && method(base.callee, 'HttpApiBuilder', 'layer') && 1 === base.arguments.length && apiIdentity(base.arguments[0]) === api && node.arguments.length > 0 && node.arguments.every((argument)=>__rspack_external__babel_types_6e8337dd.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 || !__rspack_external__babel_types_6e8337dd.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 (!__rspack_external__babel_types_6e8337dd.isStringLiteral(route, {
+                value: '/rpc'
+            }) || !__rspack_external__babel_types_6e8337dd.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 || !__rspack_external__babel_types_6e8337dd.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 (!__rspack_external__babel_types_6e8337dd.isCallExpression(layerInit) || !__rspack_external__babel_types_6e8337dd.isMemberExpression(layerInit.callee) || layerInit.callee.computed || !__rspack_external__babel_types_6e8337dd.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 (!__rspack_external__babel_types_6e8337dd.isCallExpression(implementation) || !__rspack_external__babel_types_6e8337dd.isMemberExpression(implementation.callee) || implementation.callee.computed || !__rspack_external__babel_types_6e8337dd.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)=>__rspack_external__babel_types_6e8337dd.isArrowFunctionExpression(value) || __rspack_external__babel_types_6e8337dd.isFunctionExpression(value));
+        };
+        const runtime = (node)=>guarded(node, (node)=>{
+                const init = initialized(node);
+                if (init) return runtime(init);
+                if (!__rspack_external__babel_types_6e8337dd.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 && __rspack_external__babel_types_6e8337dd.isFunctionDeclaration(decl) ? decl : initialized(node.callee);
+                if (!factory || !__rspack_external__babel_types_6e8337dd.isFunctionDeclaration(factory) && !__rspack_external__babel_types_6e8337dd.isArrowFunctionExpression(factory) && !__rspack_external__babel_types_6e8337dd.isFunctionExpression(factory) || factory.params.length || node.arguments.length || !factory.body) return false;
+                if (!__rspack_external__babel_types_6e8337dd.isBlockStatement(factory.body)) return runtime(factory.body);
+                const statements = factory.body.body;
+                const last = statements.at(-1);
+                return statements.slice(0, -1).every((statement)=>__rspack_external__babel_types_6e8337dd.isVariableDeclaration(statement)) && !!last && __rspack_external__babel_types_6e8337dd.isReturnStatement(last) && !!last.argument && runtime(last.argument);
+            });
+        const root = entry.file.program.body.find((statement)=>__rspack_external__babel_types_6e8337dd.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
+        });
+    }
+}
+export { createEffectApiImportResolver, strictEffectRuntimeTopologyViolation };

package/dist/types/strict-effect-runtime.d.ts

@@ -0,0 +1,10 @@
+/** A bounded, owner-local source resolver; never executes application modules. */
+export interface EffectApiSource {
+    readonly id: string;
+    readonly source: string;
+    readonly resolveImport?: (specifier: string) => EffectApiSource | undefined;
+}
+export type EffectApiImportResolver = (specifier: string) => EffectApiSource | undefined;
+export declare function createEffectApiImportResolver(filename: string): EffectApiImportResolver;
+/** Proves binding identity and an exported composition, not the occurrence of names. */
+export declare function strictEffectRuntimeTopologyViolation(source: string, resolveImport?: EffectApiImportResolver): string | undefined;

package/package.json

@@ -23,7 +23,7 @@
   "engines": {
     "node": ">=20"
   },
-  "version": "3.9.0-ultramodern.1",
+  "version": "3.9.0-ultramodern.3",
   "types": "./dist/types/index.d.ts",
   "main": "./dist/esm-node/index.js",
   "typesVersions": {
@@ -45,6 +45,11 @@
       },
       "default": "./dist/esm-node/index.js"
     },
+    "./strict-effect-runtime": {
+      "types": "./dist/types/strict-effect-runtime.d.ts",
+      "import": "./dist/esm-node/strict-effect-runtime.js",
+      "require": "./dist/cjs/strict-effect-runtime.cjs"
+    },
     "./oxlint-plugin": {
       "types": "./dist/types/oxlint-plugin.d.ts",
       "node": {
@@ -58,12 +63,15 @@
     "dist"
   ],
   "dependencies": {
-    "oxlint": "1.80.0"
+    "@babel/parser": "^8.0.4",
+    "@babel/traverse": "^8.0.4",
+    "@babel/types": "^8.0.4",
+    "oxlint": "1.81.0"
   },
   "devDependencies": {
     "@rslib/core": "1.0.0",
     "@scripts/rstest-config": "2.66.0",
-    "@types/node": "^26.2.0",
+    "@types/node": "^26.4.1",
     "@typescript/native-preview": "7.0.0-dev.20260707.2"
   },
   "sideEffects": false,