import { sameFileIdentity } from "../infra/file-identity.js";

import { resolveBundledPluginsDir } from "./bundled-dir.js";

import { getCachedPluginJitiLoader, type PluginJitiLoaderCache } from "./jiti-loader-cache.js";

import { tryNativeRequireJavaScriptModule } from "./native-module-require.js";

import { resolveBundledPluginPublicSurfacePath } from "./public-surface-runtime.js";

import {

isBundledPluginExtensionPath,

resolvePluginLoaderJitiTryNative,

resolveLoaderPackageRoot,

} from "./sdk-alias.js";

import { resolvePluginLoaderJitiTryNative, resolveLoaderPackageRoot } from "./sdk-alias.js";

const OPENCLAW_PACKAGE_ROOT =

resolveLoaderPackageRoot({

} | null

>();

const jitiLoaders: PluginJitiLoaderCache = new Map();

const sharedBundledPublicSurfaceJitiLoaders: PluginJitiLoaderCache = new Map();

function isSourceArtifactPath(modulePath: string): boolean {

switch (path.extname(modulePath).toLowerCase()) {

}

function getJiti(modulePath: string) {

const tryNative = resolvePluginLoaderJitiTryNative(modulePath, { preferBuiltDist: true });

const sharedLoader = getSharedBundledPublicSurfaceJiti(modulePath, tryNative);

if (sharedLoader) {

return sharedLoader;

}

const loader = getCachedPluginJitiLoader({

return getCachedPluginJitiLoader({

cache: jitiLoaders,

modulePath,

importerUrl: import.meta.url,

preferBuiltDist: true,

jitiFilename: import.meta.url,

});

return loader;

}

function loadPublicSurfaceModule(modulePath: string): unknown {

const tryNative = resolvePluginLoaderJitiTryNative(modulePath, { preferBuiltDist: true });

if (tryNative) {

const nativeModule = tryNativeRequireJavaScriptModule(modulePath, { allowWindows: true });

if (nativeModule.ok) {

return nativeModule.moduleExport;

}

}

if (canUseSourceArtifactRequire({ modulePath, tryNative })) {

return sourceArtifactRequire(modulePath);

}

return getJiti(modulePath)(modulePath);

}

function getSharedBundledPublicSurfaceJiti(modulePath: string, tryNative: boolean) {

const bundledPluginsDir = resolveBundledPluginsDir();

if (

!isBundledPluginExtensionPath({

modulePath,

openClawPackageRoot: OPENCLAW_PACKAGE_ROOT,

...(bundledPluginsDir ? { bundledPluginsDir } : {}),

})

) {

return null;

}

const cacheKey = tryNative ? "bundled:native" : "bundled:source";

return getCachedPluginJitiLoader({

cache: sharedBundledPublicSurfaceJitiLoaders,

modulePath,

importerUrl: import.meta.url,

jitiFilename: import.meta.url,

cacheScopeKey: cacheKey,

tryNative,

});

}

// oxlint-disable-next-line typescript/no-unnecessary-type-parameters -- Dynamic public artifact loaders use caller-supplied module surface types.

export function loadBundledPluginPublicArtifactModuleSync<T extends object>(params: {

dirName: string;

`Unable to resolve bundled plugin public surface ${params.dirName}/${params.artifactBasename}`,

);

}

const preparedLocation = location;

const cached =

loadedPublicSurfaceModules.get(location.modulePath) ??

loadedPublicSurfaceModules.get(preparedLocation.modulePath);

const cached = loadedPublicSurfaceModules.get(location.modulePath);

if (cached) {

return cached as T;

}

const opened = openBoundaryFileSync({

absolutePath: preparedLocation.modulePath,

rootPath: preparedLocation.boundaryRoot,

absolutePath: location.modulePath,

rootPath: location.boundaryRoot,

boundaryLabel:

preparedLocation.boundaryRoot === OPENCLAW_PACKAGE_ROOT

? "OpenClaw package root"

: "plugin root",

location.boundaryRoot === OPENCLAW_PACKAGE_ROOT ? "OpenClaw package root" : "plugin root",

rejectHardlinks: true,

});

if (!opened.ok) {

const sentinel = {} as T;

loadedPublicSurfaceModules.set(location.modulePath, sentinel);

loadedPublicSurfaceModules.set(preparedLocation.modulePath, sentinel);

loadedPublicSurfaceModules.set(validatedPath, sentinel);

try {

const loaded = loadPublicSurfaceModule(validatedPath) as T;

Object.assign(sentinel, loaded);

return sentinel;

} catch (error) {

loadedPublicSurfaceModules.delete(location.modulePath);

loadedPublicSurfaceModules.delete(preparedLocation.modulePath);

loadedPublicSurfaceModules.delete(validatedPath);

throw error;

}

loadedPublicSurfaceModules.clear();

publicSurfaceLocations.clear();

jitiLoaders.clear();

sharedBundledPublicSurfaceJitiLoaders.clear();

}