const nodeRequire = createRequire(import.meta.url);

const moduleLoaders: PluginModuleLoaderCache = new Map();

const entryBoundaryInfoCache = new Map<string, BundledEntryBoundaryInfo>();

const resolvedModulePaths = new Map<string, string>();

const loadedModuleExports = new Map<string, unknown>();

const disableBundledEntrySourceFallbackEnv = "OPENCLAW_DISABLE_BUNDLED_ENTRY_SOURCE_FALLBACK";

boundaryRoot: string;

};

type BundledEntryBoundaryInfo = {

importerPath: string;

importerDir: string;

boundaryRoot: string;

packageRoot: string | null;

};

function resolveBundledEntryBoundaryInfo(importMetaUrl: string): BundledEntryBoundaryInfo {

const cacheKey = `${process.argv[1] ?? ""}\0${importMetaUrl}`;

const cached = entryBoundaryInfoCache.get(cacheKey);

if (cached) {

return cached;

}

const importerPath = fileURLToPath(importMetaUrl);

const importerDir = path.dirname(importerPath);

const boundaryRoot = path.dirname(importerPath);

const info = {

importerPath,

importerDir,

boundaryRoot,

packageRoot:

resolveLoaderPackageRoot({

modulePath: importerPath,

moduleUrl: importMetaUrl,

cwd: importerDir,

argv1: process.argv[1],

}) ?? null,

};

entryBoundaryInfoCache.set(cacheKey, info);

return info;

}

function addBundledEntryCandidates(

candidates: BundledEntryModuleCandidate[],

basePath: string,

importMetaUrl: string,

specifier: string,

): BundledEntryModuleCandidate[] {

const importerPath = fileURLToPath(importMetaUrl);

const importerDir = path.dirname(importerPath);

const boundaryRoot = resolveEntryBoundaryRoot(importMetaUrl);

const { importerPath, importerDir, boundaryRoot, packageRoot } =

resolveBundledEntryBoundaryInfo(importMetaUrl);

const candidates: BundledEntryModuleCandidate[] = [];

const primaryResolved = path.resolve(importerDir, specifier);

addBundledEntryCandidates(candidates, primaryResolved, boundaryRoot);

);

}

const packageRoot = resolveLoaderPackageRoot({

modulePath: importerPath,

moduleUrl: importMetaUrl,

cwd: importerDir,

argv1: process.argv[1],

});

if (!packageRoot) {

return candidates;

}

].join(" ");

}

function createBundledEntryModulePathCacheKey(importMetaUrl: string, specifier: string): string {

const sourceFallbackDisabled = isTruthyEnvFlag(process.env[disableBundledEntrySourceFallbackEnv]);

return `${sourceFallbackDisabled ? "1" : "0"}\0${importMetaUrl}\0${specifier}`;

}

function resolveBundledEntryModulePath(importMetaUrl: string, specifier: string): string {

const cacheKey = createBundledEntryModulePathCacheKey(importMetaUrl, specifier);

const cached = resolvedModulePaths.get(cacheKey);

if (cached) {

return cached;

}

const candidates = resolveBundledEntryModuleCandidates(importMetaUrl, specifier);

const fallbackCandidate = candidates[0] ?? {

path: path.resolve(path.dirname(fileURLToPath(importMetaUrl)), specifier),

});

if (opened.ok) {

fs.closeSync(opened.fd);

resolvedModulePaths.set(cacheKey, opened.path);

return opened.path;

}

firstFailure ??= { candidate, failure: opened };