@vibe-lark/larkpal 0.1.84 → 0.1.86

package/dist/facade-loader-DFzIYYt_-CIr4HKtE.mjs

@@ -0,0 +1,194 @@
+import { t as resolveBundledPluginsDir } from "./bundled-dir-U738ay4K-DXK0q_TV.mjs";
+import { r as openBoundaryFileSync } from "./boundary-file-read-BSd9MXPy--KThL5e6.mjs";
+import { c as resolveBundledPluginPublicSurfacePath, l as resolveBundledPluginSourcePublicSurfacePath, r as resolveLoaderPackageRoot, t as getCachedPluginJitiLoader } from "./jiti-loader-cache-Bat69wam-D6hCxboy.mjs";
+import { createRequire } from "node:module";
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+//#region node_modules/.pnpm/openclaw@2026.4.22_@napi-rs+canvas@0.1.99/node_modules/openclaw/dist/facade-resolution-shared-BjzuY_sO.js
+function createFacadeResolutionKey$1(params) {
+	return `${params.dirName}::${params.artifactBasename}::${params.bundledPluginsDir ? path.resolve(params.bundledPluginsDir) : "<default>"}`;
+}
+function resolveCachedFacadeModuleLocation(params) {
+	if (params.cache.has(params.key)) return params.cache.get(params.key) ?? null;
+	const resolved = params.resolve();
+	params.cache.set(params.key, resolved);
+	return resolved;
+}
+function resolveFacadeBoundaryRoot(params) {
+	if (!params.bundledPluginsDir) return params.packageRoot;
+	const resolvedBundledPluginsDir = path.resolve(params.bundledPluginsDir);
+	return params.modulePath.startsWith(`${resolvedBundledPluginsDir}${path.sep}`) ? resolvedBundledPluginsDir : params.packageRoot;
+}
+function resolveBundledFacadeModuleLocation(params) {
+	const preferSource = !params.currentModulePath.includes(`${path.sep}dist${path.sep}`);
+	const publicSurfaceParams = {
+		rootDir: params.packageRoot,
+		env: params.env,
+		...params.bundledPluginsDir ? { bundledPluginsDir: params.bundledPluginsDir } : {},
+		dirName: params.dirName,
+		artifactBasename: params.artifactBasename
+	};
+	const modulePath = preferSource ? resolveBundledPluginSourcePublicSurfacePath({
+		dirName: params.dirName,
+		artifactBasename: params.artifactBasename,
+		sourceRoot: params.bundledPluginsDir ?? path.resolve(params.packageRoot, "extensions")
+	}) ?? resolveBundledPluginPublicSurfacePath(publicSurfaceParams) : resolveBundledPluginPublicSurfacePath(publicSurfaceParams);
+	return modulePath ? {
+		modulePath,
+		boundaryRoot: resolveFacadeBoundaryRoot({
+			modulePath,
+			bundledPluginsDir: params.bundledPluginsDir,
+			packageRoot: params.packageRoot
+		})
+	} : null;
+}
+//#endregion
+//#region node_modules/.pnpm/openclaw@2026.4.22_@napi-rs+canvas@0.1.99/node_modules/openclaw/dist/facade-loader-DFzIYYt_.js
+const CURRENT_MODULE_PATH = fileURLToPath(import.meta.url);
+const nodeRequire = createRequire(import.meta.url);
+const jitiLoaders = /* @__PURE__ */ new Map();
+const loadedFacadeModules = /* @__PURE__ */ new Map();
+const loadedFacadePluginIds = /* @__PURE__ */ new Set();
+const cachedFacadeModuleLocationsByKey = /* @__PURE__ */ new Map();
+let facadeLoaderJitiFactory;
+let cachedOpenClawPackageRoot;
+function getJitiFactory() {
+	if (facadeLoaderJitiFactory) return facadeLoaderJitiFactory;
+	const { createJiti } = nodeRequire("jiti");
+	facadeLoaderJitiFactory = createJiti;
+	return facadeLoaderJitiFactory;
+}
+function getOpenClawPackageRoot() {
+	if (cachedOpenClawPackageRoot) return cachedOpenClawPackageRoot;
+	cachedOpenClawPackageRoot = resolveLoaderPackageRoot({
+		modulePath: fileURLToPath(import.meta.url),
+		moduleUrl: import.meta.url
+	}) ?? fileURLToPath(new URL("../..", import.meta.url));
+	return cachedOpenClawPackageRoot;
+}
+function createFacadeResolutionKey(params) {
+	const bundledPluginsDir = resolveBundledPluginsDir(params.env ?? process.env);
+	return createFacadeResolutionKey$1({
+		...params,
+		bundledPluginsDir
+	});
+}
+function resolveFacadeModuleLocationUncached(params) {
+	const bundledPluginsDir = resolveBundledPluginsDir(params.env ?? process.env);
+	return resolveBundledFacadeModuleLocation({
+		...params,
+		currentModulePath: CURRENT_MODULE_PATH,
+		packageRoot: getOpenClawPackageRoot(),
+		bundledPluginsDir
+	});
+}
+function resolveFacadeModuleLocation(params) {
+	return resolveCachedFacadeModuleLocation({
+		cache: cachedFacadeModuleLocationsByKey,
+		key: createFacadeResolutionKey(params),
+		resolve: () => resolveFacadeModuleLocationUncached(params)
+	});
+}
+function getJiti(modulePath) {
+	return getCachedPluginJitiLoader({
+		cache: jitiLoaders,
+		modulePath,
+		importerUrl: import.meta.url,
+		preferBuiltDist: true,
+		jitiFilename: import.meta.url,
+		createLoader: getJitiFactory()
+	});
+}
+function createLazyFacadeValueLoader(load) {
+	let loaded = false;
+	let value;
+	return () => {
+		if (!loaded) {
+			value = load();
+			loaded = true;
+		}
+		return value;
+	};
+}
+function createLazyFacadeProxyValue(params) {
+	const resolve = createLazyFacadeValueLoader(params.load);
+	return new Proxy(params.target, {
+		defineProperty(_target, property, descriptor) {
+			return Reflect.defineProperty(resolve(), property, descriptor);
+		},
+		deleteProperty(_target, property) {
+			return Reflect.deleteProperty(resolve(), property);
+		},
+		get(_target, property, receiver) {
+			return Reflect.get(resolve(), property, receiver);
+		},
+		getOwnPropertyDescriptor(_target, property) {
+			return Reflect.getOwnPropertyDescriptor(resolve(), property);
+		},
+		getPrototypeOf() {
+			return Reflect.getPrototypeOf(resolve());
+		},
+		has(_target, property) {
+			return Reflect.has(resolve(), property);
+		},
+		isExtensible() {
+			return Reflect.isExtensible(resolve());
+		},
+		ownKeys() {
+			return Reflect.ownKeys(resolve());
+		},
+		preventExtensions() {
+			return Reflect.preventExtensions(resolve());
+		},
+		set(_target, property, value, receiver) {
+			return Reflect.set(resolve(), property, value, receiver);
+		},
+		setPrototypeOf(_target, prototype) {
+			return Reflect.setPrototypeOf(resolve(), prototype);
+		}
+	});
+}
+function createLazyFacadeObjectValue(load) {
+	return createLazyFacadeProxyValue({
+		load,
+		target: {}
+	});
+}
+function loadFacadeModuleAtLocationSync(params) {
+	const cached = loadedFacadeModules.get(params.location.modulePath);
+	if (cached) return cached;
+	const opened = openBoundaryFileSync({
+		absolutePath: params.location.modulePath,
+		rootPath: params.location.boundaryRoot,
+		boundaryLabel: params.location.boundaryRoot === getOpenClawPackageRoot() ? "OpenClaw package root" : (() => {
+			const bundledDir = resolveBundledPluginsDir();
+			return bundledDir && path.resolve(params.location.boundaryRoot) === path.resolve(bundledDir) ? "bundled plugin directory" : "plugin root";
+		})(),
+		rejectHardlinks: false
+	});
+	if (!opened.ok) throw new Error(`Unable to open bundled plugin public surface ${params.location.modulePath}`, { cause: opened.error });
+	fs.closeSync(opened.fd);
+	const sentinel = {};
+	loadedFacadeModules.set(params.location.modulePath, sentinel);
+	let loaded;
+	try {
+		loaded = params.loadModule?.(params.location.modulePath) ?? getJiti(params.location.modulePath)(params.location.modulePath);
+		Object.assign(sentinel, loaded);
+		loadedFacadePluginIds.add(typeof params.trackedPluginId === "function" ? params.trackedPluginId() : params.trackedPluginId);
+	} catch (err) {
+		loadedFacadeModules.delete(params.location.modulePath);
+		throw err;
+	}
+	return sentinel;
+}
+function loadBundledPluginPublicSurfaceModuleSync(params) {
+	const location = resolveFacadeModuleLocation(params);
+	if (!location) throw new Error(`Unable to resolve bundled plugin public surface ${params.dirName}/${params.artifactBasename}`);
+	return loadFacadeModuleAtLocationSync({
+		location,
+		trackedPluginId: params.trackedPluginId ?? params.dirName
+	});
+}
+//#endregion
+export { resolveBundledFacadeModuleLocation as a, createFacadeResolutionKey$1 as i, loadBundledPluginPublicSurfaceModuleSync as n, resolveCachedFacadeModuleLocation as o, loadFacadeModuleAtLocationSync as r, createLazyFacadeObjectValue as t };