@vibe-lark/larkpal 0.1.86 → 0.1.87

package/dist/boundary-file-read-BSd9MXPy--KThL5e6.mjs

@@ -1,594 +0,0 @@
-import { o as normalizeLowercaseStringOrEmpty } from "./home-dir-C44RaPME-CBRS4HLP.mjs";
-import fs from "node:fs";
-import path from "node:path";
-import "node:fs/promises";
-import os from "node:os";
-//#region node_modules/.pnpm/openclaw@2026.4.22_@napi-rs+canvas@0.1.99/node_modules/openclaw/dist/boundary-path-BSBSMt0u.js
-const NOT_FOUND_CODES = new Set(["ENOENT", "ENOTDIR"]);
-const SYMLINK_OPEN_CODES = new Set([
-	"ELOOP",
-	"EINVAL",
-	"ENOTSUP"
-]);
-const PARENT_SEGMENT_PREFIX = /^\.\.(?:[\\/]|$)/u;
-function normalizeWindowsPathForComparison(input) {
-	let normalized = path.win32.normalize(input);
-	if (normalized.startsWith("\\\\?\\")) {
-		normalized = normalized.slice(4);
-		if (normalized.toUpperCase().startsWith("UNC\\")) normalized = `\\\\${normalized.slice(4)}`;
-	}
-	return normalizeLowercaseStringOrEmpty(normalized.replaceAll("/", "\\"));
-}
-function isNodeError(value) {
-	return Boolean(value && typeof value === "object" && "code" in value);
-}
-function hasNodeErrorCode(value, code) {
-	return isNodeError(value) && value.code === code;
-}
-function isNotFoundPathError(value) {
-	return isNodeError(value) && typeof value.code === "string" && NOT_FOUND_CODES.has(value.code);
-}
-function isSymlinkOpenError(value) {
-	return isNodeError(value) && typeof value.code === "string" && SYMLINK_OPEN_CODES.has(value.code);
-}
-function isPathInside(root, target) {
-	if (process.platform === "win32") {
-		const rootForCompare = normalizeWindowsPathForComparison(path.win32.resolve(root));
-		const targetForCompare = normalizeWindowsPathForComparison(path.win32.resolve(target));
-		const relative = path.win32.relative(rootForCompare, targetForCompare);
-		return relative === "" || !PARENT_SEGMENT_PREFIX.test(relative) && !path.win32.isAbsolute(relative);
-	}
-	const resolvedRoot = path.resolve(root);
-	const resolvedTarget = path.resolve(target);
-	const relative = path.relative(resolvedRoot, resolvedTarget);
-	return relative === "" || !PARENT_SEGMENT_PREFIX.test(relative) && !path.isAbsolute(relative);
-}
-Object.freeze({
-	allowFinalSymlinkForUnlink: false,
-	allowFinalHardlinkForUnlink: false
-}), Object.freeze({
-	allowFinalSymlinkForUnlink: true,
-	allowFinalHardlinkForUnlink: true
-});
-function resolveBoundaryPathSync(params) {
-	const rootPath = path.resolve(params.rootPath);
-	const absolutePath = path.resolve(params.absolutePath);
-	const context = createBoundaryResolutionContext({
-		resolveParams: params,
-		rootPath,
-		absolutePath,
-		rootCanonicalPath: params.rootCanonicalPath ? path.resolve(params.rootCanonicalPath) : resolvePathViaExistingAncestorSync(rootPath),
-		outsideLexicalCanonicalPath: resolveOutsideLexicalCanonicalPathSync({
-			rootPath,
-			absolutePath
-		})
-	});
-	const outsideResult = resolveOutsideBoundaryPathSync({
-		boundaryLabel: params.boundaryLabel,
-		context
-	});
-	if (outsideResult) return outsideResult;
-	return resolveBoundaryPathLexicalSync({
-		params,
-		absolutePath: context.absolutePath,
-		rootPath: context.rootPath,
-		rootCanonicalPath: context.rootCanonicalPath
-	});
-}
-function isPromiseLike(value) {
-	return Boolean(value && (typeof value === "object" || typeof value === "function") && "then" in value && typeof value.then === "function");
-}
-function createLexicalTraversalState(params) {
-	return {
-		segments: path.relative(params.rootPath, params.absolutePath).split(path.sep).filter(Boolean),
-		allowFinalSymlink: params.params.policy?.allowFinalSymlinkForUnlink === true,
-		canonicalCursor: params.rootCanonicalPath,
-		lexicalCursor: params.rootPath,
-		preserveFinalSymlink: false
-	};
-}
-function assertLexicalCursorInsideBoundary(params) {
-	assertInsideBoundary({
-		boundaryLabel: params.params.boundaryLabel,
-		rootCanonicalPath: params.rootCanonicalPath,
-		candidatePath: params.candidatePath,
-		absolutePath: params.absolutePath
-	});
-}
-function applyMissingSuffixToCanonicalCursor(params) {
-	const missingSuffix = params.state.segments.slice(params.missingFromIndex);
-	params.state.canonicalCursor = path.resolve(params.state.canonicalCursor, ...missingSuffix);
-	assertLexicalCursorInsideBoundary({
-		params: params.params,
-		rootCanonicalPath: params.rootCanonicalPath,
-		candidatePath: params.state.canonicalCursor,
-		absolutePath: params.absolutePath
-	});
-}
-function advanceCanonicalCursorForSegment(params) {
-	params.state.canonicalCursor = path.resolve(params.state.canonicalCursor, params.segment);
-	assertLexicalCursorInsideBoundary({
-		params: params.params,
-		rootCanonicalPath: params.rootCanonicalPath,
-		candidatePath: params.state.canonicalCursor,
-		absolutePath: params.absolutePath
-	});
-}
-function finalizeLexicalResolution(params) {
-	assertLexicalCursorInsideBoundary({
-		params: params.params,
-		rootCanonicalPath: params.rootCanonicalPath,
-		candidatePath: params.state.canonicalCursor,
-		absolutePath: params.absolutePath
-	});
-	return buildResolvedBoundaryPath({
-		absolutePath: params.absolutePath,
-		canonicalPath: params.state.canonicalCursor,
-		rootPath: params.rootPath,
-		rootCanonicalPath: params.rootCanonicalPath,
-		kind: params.kind
-	});
-}
-function handleLexicalLstatFailure(params) {
-	if (!isNotFoundPathError(params.error)) return false;
-	applyMissingSuffixToCanonicalCursor({
-		state: params.state,
-		missingFromIndex: params.missingFromIndex,
-		rootCanonicalPath: params.rootCanonicalPath,
-		params: params.resolveParams,
-		absolutePath: params.absolutePath
-	});
-	return true;
-}
-function handleLexicalStatReadFailure(params) {
-	if (handleLexicalLstatFailure({
-		error: params.error,
-		state: params.state,
-		missingFromIndex: params.missingFromIndex,
-		rootCanonicalPath: params.rootCanonicalPath,
-		resolveParams: params.resolveParams,
-		absolutePath: params.absolutePath
-	})) return null;
-	throw params.error;
-}
-function handleLexicalStatDisposition(params) {
-	if (!params.isSymbolicLink) {
-		advanceCanonicalCursorForSegment({
-			state: params.state,
-			segment: params.segment,
-			rootCanonicalPath: params.rootCanonicalPath,
-			params: params.resolveParams,
-			absolutePath: params.absolutePath
-		});
-		return "continue";
-	}
-	if (params.state.allowFinalSymlink && params.isLast) {
-		params.state.preserveFinalSymlink = true;
-		advanceCanonicalCursorForSegment({
-			state: params.state,
-			segment: params.segment,
-			rootCanonicalPath: params.rootCanonicalPath,
-			params: params.resolveParams,
-			absolutePath: params.absolutePath
-		});
-		return "break";
-	}
-	return "resolve-link";
-}
-function applyResolvedSymlinkHop(params) {
-	if (!isPathInside(params.rootCanonicalPath, params.linkCanonical)) throw symlinkEscapeError({
-		boundaryLabel: params.boundaryLabel,
-		rootCanonicalPath: params.rootCanonicalPath,
-		symlinkPath: params.state.lexicalCursor
-	});
-	params.state.canonicalCursor = params.linkCanonical;
-	params.state.lexicalCursor = params.linkCanonical;
-}
-function readLexicalStat(params) {
-	try {
-		const stat = params.read(params.state.lexicalCursor);
-		if (isPromiseLike(stat)) return Promise.resolve(stat).catch((error) => handleLexicalStatReadFailure({
-			...params,
-			error
-		}));
-		return stat;
-	} catch (error) {
-		return handleLexicalStatReadFailure({
-			...params,
-			error
-		});
-	}
-}
-function resolveAndApplySymlinkHop(params) {
-	const linkCanonical = params.resolveLinkCanonical(params.state.lexicalCursor);
-	if (isPromiseLike(linkCanonical)) return Promise.resolve(linkCanonical).then((value) => applyResolvedSymlinkHop({
-		state: params.state,
-		linkCanonical: value,
-		rootCanonicalPath: params.rootCanonicalPath,
-		boundaryLabel: params.boundaryLabel
-	}));
-	applyResolvedSymlinkHop({
-		state: params.state,
-		linkCanonical,
-		rootCanonicalPath: params.rootCanonicalPath,
-		boundaryLabel: params.boundaryLabel
-	});
-}
-function resolveBoundaryPathLexicalSync(params) {
-	const state = createLexicalTraversalState(params);
-	for (let idx = 0; idx < state.segments.length; idx += 1) {
-		const segment = state.segments[idx] ?? "";
-		const isLast = idx === state.segments.length - 1;
-		state.lexicalCursor = path.join(state.lexicalCursor, segment);
-		const maybeStat = readLexicalStat({
-			state,
-			missingFromIndex: idx,
-			rootCanonicalPath: params.rootCanonicalPath,
-			resolveParams: params.params,
-			absolutePath: params.absolutePath,
-			read: (cursor) => fs.lstatSync(cursor)
-		});
-		if (isPromiseLike(maybeStat)) throw new Error("Unexpected async lexical stat");
-		const stat = maybeStat;
-		if (!stat) break;
-		const disposition = handleLexicalStatDisposition({
-			state,
-			isSymbolicLink: stat.isSymbolicLink(),
-			segment,
-			isLast,
-			rootCanonicalPath: params.rootCanonicalPath,
-			resolveParams: params.params,
-			absolutePath: params.absolutePath
-		});
-		if (disposition === "continue") continue;
-		if (disposition === "break") break;
-		if (isPromiseLike(resolveAndApplySymlinkHop({
-			state,
-			rootCanonicalPath: params.rootCanonicalPath,
-			boundaryLabel: params.params.boundaryLabel,
-			resolveLinkCanonical: (cursor) => resolveSymlinkHopPathSync(cursor)
-		}))) throw new Error("Unexpected async symlink resolution");
-	}
-	const kind = getPathKindSync(params.absolutePath, state.preserveFinalSymlink);
-	return finalizeLexicalResolution({
-		...params,
-		state,
-		kind
-	});
-}
-function resolveCanonicalOutsideLexicalPath(params) {
-	return params.outsideLexicalCanonicalPath ?? params.absolutePath;
-}
-function createBoundaryResolutionContext(params) {
-	const lexicalInside = isPathInside(params.rootPath, params.absolutePath);
-	const canonicalOutsideLexicalPath = resolveCanonicalOutsideLexicalPath({
-		absolutePath: params.absolutePath,
-		outsideLexicalCanonicalPath: params.outsideLexicalCanonicalPath
-	});
-	assertLexicalBoundaryOrCanonicalAlias({
-		skipLexicalRootCheck: params.resolveParams.skipLexicalRootCheck,
-		lexicalInside,
-		canonicalOutsideLexicalPath,
-		rootCanonicalPath: params.rootCanonicalPath,
-		boundaryLabel: params.resolveParams.boundaryLabel,
-		rootPath: params.rootPath,
-		absolutePath: params.absolutePath
-	});
-	return {
-		rootPath: params.rootPath,
-		absolutePath: params.absolutePath,
-		rootCanonicalPath: params.rootCanonicalPath,
-		lexicalInside,
-		canonicalOutsideLexicalPath
-	};
-}
-function resolveOutsideBoundaryPathSync(params) {
-	if (params.context.lexicalInside) return null;
-	const kind = getPathKindSync(params.context.absolutePath, false);
-	return buildOutsideBoundaryPathFromContext({
-		boundaryLabel: params.boundaryLabel,
-		context: params.context,
-		kind
-	});
-}
-function buildOutsideBoundaryPathFromContext(params) {
-	return buildOutsideLexicalBoundaryPath({
-		boundaryLabel: params.boundaryLabel,
-		rootCanonicalPath: params.context.rootCanonicalPath,
-		absolutePath: params.context.absolutePath,
-		canonicalOutsideLexicalPath: params.context.canonicalOutsideLexicalPath,
-		rootPath: params.context.rootPath,
-		kind: params.kind
-	});
-}
-function resolveOutsideLexicalCanonicalPathSync(params) {
-	if (isPathInside(params.rootPath, params.absolutePath)) return;
-	return resolvePathViaExistingAncestorSync(params.absolutePath);
-}
-function buildOutsideLexicalBoundaryPath(params) {
-	assertInsideBoundary({
-		boundaryLabel: params.boundaryLabel,
-		rootCanonicalPath: params.rootCanonicalPath,
-		candidatePath: params.canonicalOutsideLexicalPath,
-		absolutePath: params.absolutePath
-	});
-	return buildResolvedBoundaryPath({
-		absolutePath: params.absolutePath,
-		canonicalPath: params.canonicalOutsideLexicalPath,
-		rootPath: params.rootPath,
-		rootCanonicalPath: params.rootCanonicalPath,
-		kind: params.kind
-	});
-}
-function assertLexicalBoundaryOrCanonicalAlias(params) {
-	if (params.skipLexicalRootCheck || params.lexicalInside) return;
-	if (isPathInside(params.rootCanonicalPath, params.canonicalOutsideLexicalPath)) return;
-	throw pathEscapeError({
-		boundaryLabel: params.boundaryLabel,
-		rootPath: params.rootPath,
-		absolutePath: params.absolutePath
-	});
-}
-function buildResolvedBoundaryPath(params) {
-	return {
-		absolutePath: params.absolutePath,
-		canonicalPath: params.canonicalPath,
-		rootPath: params.rootPath,
-		rootCanonicalPath: params.rootCanonicalPath,
-		relativePath: relativeInsideRoot(params.rootCanonicalPath, params.canonicalPath),
-		exists: params.kind.exists,
-		kind: params.kind.kind
-	};
-}
-function resolvePathViaExistingAncestorSync(targetPath) {
-	const normalized = path.resolve(targetPath);
-	let cursor = normalized;
-	const missingSuffix = [];
-	while (!isFilesystemRoot(cursor) && !fs.existsSync(cursor)) {
-		missingSuffix.unshift(path.basename(cursor));
-		const parent = path.dirname(cursor);
-		if (parent === cursor) break;
-		cursor = parent;
-	}
-	if (!fs.existsSync(cursor)) return normalized;
-	try {
-		const resolvedAncestor = path.resolve(fs.realpathSync(cursor));
-		if (missingSuffix.length === 0) return resolvedAncestor;
-		return path.resolve(resolvedAncestor, ...missingSuffix);
-	} catch {
-		return normalized;
-	}
-}
-function getPathKindSync(absolutePath, preserveFinalSymlink) {
-	try {
-		return {
-			exists: true,
-			kind: toResolvedKind(preserveFinalSymlink ? fs.lstatSync(absolutePath) : fs.statSync(absolutePath))
-		};
-	} catch (error) {
-		if (isNotFoundPathError(error)) return {
-			exists: false,
-			kind: "missing"
-		};
-		throw error;
-	}
-}
-function toResolvedKind(stat) {
-	if (stat.isFile()) return "file";
-	if (stat.isDirectory()) return "directory";
-	if (stat.isSymbolicLink()) return "symlink";
-	return "other";
-}
-function relativeInsideRoot(rootPath, targetPath) {
-	const relative = path.relative(path.resolve(rootPath), path.resolve(targetPath));
-	if (!relative || relative === ".") return "";
-	if (relative.startsWith("..") || path.isAbsolute(relative)) return "";
-	return relative;
-}
-function assertInsideBoundary(params) {
-	if (isPathInside(params.rootCanonicalPath, params.candidatePath)) return;
-	throw new Error(`Path resolves outside ${params.boundaryLabel} (${shortPath(params.rootCanonicalPath)}): ${shortPath(params.absolutePath)}`);
-}
-function pathEscapeError(params) {
-	return /* @__PURE__ */ new Error(`Path escapes ${params.boundaryLabel} (${shortPath(params.rootPath)}): ${shortPath(params.absolutePath)}`);
-}
-function symlinkEscapeError(params) {
-	return /* @__PURE__ */ new Error(`Symlink escapes ${params.boundaryLabel} (${shortPath(params.rootCanonicalPath)}): ${shortPath(params.symlinkPath)}`);
-}
-function shortPath(value) {
-	const home = os.homedir();
-	if (value.startsWith(home)) return `~${value.slice(home.length)}`;
-	return value;
-}
-function isFilesystemRoot(candidate) {
-	return path.parse(candidate).root === candidate;
-}
-function resolveSymlinkHopPathSync(symlinkPath) {
-	try {
-		return path.resolve(fs.realpathSync(symlinkPath));
-	} catch (error) {
-		if (!isNotFoundPathError(error)) throw error;
-		const linkTarget = fs.readlinkSync(symlinkPath);
-		return resolvePathViaExistingAncestorSync(path.resolve(path.dirname(symlinkPath), linkTarget));
-	}
-}
-//#endregion
-//#region node_modules/.pnpm/openclaw@2026.4.22_@napi-rs+canvas@0.1.99/node_modules/openclaw/dist/file-identity-DBd-elc3.js
-function isZero(value) {
-	return value === 0 || value === 0n;
-}
-function sameFileIdentity$1(left, right, platform = process.platform) {
-	if (left.ino !== right.ino) return false;
-	if (left.dev === right.dev) return true;
-	return platform === "win32" && (isZero(left.dev) || isZero(right.dev));
-}
-//#endregion
-//#region node_modules/.pnpm/openclaw@2026.4.22_@napi-rs+canvas@0.1.99/node_modules/openclaw/dist/safe-open-sync-X8Q1U9Y1.js
-function isExpectedPathError(error) {
-	const code = typeof error === "object" && error !== null && "code" in error ? String(error.code) : "";
-	return code === "ENOENT" || code === "ENOTDIR" || code === "ELOOP";
-}
-function sameFileIdentity(left, right) {
-	return sameFileIdentity$1(left, right);
-}
-function openVerifiedFileSync(params) {
-	const ioFs = params.ioFs ?? fs;
-	const allowedType = params.allowedType ?? "file";
-	const openReadFlags = ioFs.constants.O_RDONLY | (typeof ioFs.constants.O_NOFOLLOW === "number" ? ioFs.constants.O_NOFOLLOW : 0);
-	let fd = null;
-	try {
-		if (params.rejectPathSymlink) {
-			if (ioFs.lstatSync(params.filePath).isSymbolicLink()) return {
-				ok: false,
-				reason: "validation"
-			};
-		}
-		const realPath = params.resolvedPath ?? ioFs.realpathSync(params.filePath);
-		const preOpenStat = ioFs.lstatSync(realPath);
-		if (!isAllowedType(preOpenStat, allowedType)) return {
-			ok: false,
-			reason: "validation"
-		};
-		if (params.rejectHardlinks && preOpenStat.isFile() && preOpenStat.nlink > 1) return {
-			ok: false,
-			reason: "validation"
-		};
-		if (params.maxBytes !== void 0 && preOpenStat.isFile() && preOpenStat.size > params.maxBytes) return {
-			ok: false,
-			reason: "validation"
-		};
-		fd = ioFs.openSync(realPath, openReadFlags);
-		const openedStat = ioFs.fstatSync(fd);
-		if (!isAllowedType(openedStat, allowedType)) return {
-			ok: false,
-			reason: "validation"
-		};
-		if (params.rejectHardlinks && openedStat.isFile() && openedStat.nlink > 1) return {
-			ok: false,
-			reason: "validation"
-		};
-		if (params.maxBytes !== void 0 && openedStat.isFile() && openedStat.size > params.maxBytes) return {
-			ok: false,
-			reason: "validation"
-		};
-		if (!sameFileIdentity(preOpenStat, openedStat)) return {
-			ok: false,
-			reason: "validation"
-		};
-		const opened = {
-			ok: true,
-			path: realPath,
-			fd,
-			stat: openedStat
-		};
-		fd = null;
-		return opened;
-	} catch (error) {
-		if (isExpectedPathError(error)) return {
-			ok: false,
-			reason: "path",
-			error
-		};
-		return {
-			ok: false,
-			reason: "io",
-			error
-		};
-	} finally {
-		if (fd !== null) ioFs.closeSync(fd);
-	}
-}
-function isAllowedType(stat, allowedType) {
-	if (allowedType === "directory") return stat.isDirectory();
-	return stat.isFile();
-}
-//#endregion
-//#region node_modules/.pnpm/openclaw@2026.4.22_@napi-rs+canvas@0.1.99/node_modules/openclaw/dist/boundary-file-read-BSd9MXPy.js
-function canUseBoundaryFileOpen(ioFs) {
-	return typeof ioFs.openSync === "function" && typeof ioFs.closeSync === "function" && typeof ioFs.fstatSync === "function" && typeof ioFs.lstatSync === "function" && typeof ioFs.realpathSync === "function" && typeof ioFs.readFileSync === "function" && typeof ioFs.constants === "object" && ioFs.constants !== null;
-}
-function openBoundaryFileSync(params) {
-	const ioFs = params.ioFs ?? fs;
-	const resolved = resolveBoundaryFilePathGeneric({
-		absolutePath: params.absolutePath,
-		resolve: (absolutePath) => resolveBoundaryPathSync({
-			absolutePath,
-			rootPath: params.rootPath,
-			rootCanonicalPath: params.rootRealPath,
-			boundaryLabel: params.boundaryLabel,
-			skipLexicalRootCheck: params.skipLexicalRootCheck
-		})
-	});
-	if (resolved instanceof Promise) return toBoundaryValidationError(/* @__PURE__ */ new Error("Unexpected async boundary resolution"));
-	return finalizeBoundaryFileOpen({
-		resolved,
-		maxBytes: params.maxBytes,
-		rejectHardlinks: params.rejectHardlinks,
-		allowedType: params.allowedType,
-		ioFs
-	});
-}
-function matchBoundaryFileOpenFailure(failure, handlers) {
-	switch (failure.reason) {
-		case "path": return handlers.path ? handlers.path(failure) : handlers.fallback(failure);
-		case "validation": return handlers.validation ? handlers.validation(failure) : handlers.fallback(failure);
-		case "io": return handlers.io ? handlers.io(failure) : handlers.fallback(failure);
-	}
-	return handlers.fallback(failure);
-}
-function openBoundaryFileResolved(params) {
-	const opened = openVerifiedFileSync({
-		filePath: params.absolutePath,
-		resolvedPath: params.resolvedPath,
-		rejectHardlinks: params.rejectHardlinks ?? true,
-		maxBytes: params.maxBytes,
-		allowedType: params.allowedType,
-		ioFs: params.ioFs
-	});
-	if (!opened.ok) return opened;
-	return {
-		ok: true,
-		path: opened.path,
-		fd: opened.fd,
-		stat: opened.stat,
-		rootRealPath: params.rootRealPath
-	};
-}
-function finalizeBoundaryFileOpen(params) {
-	if ("ok" in params.resolved) return params.resolved;
-	return openBoundaryFileResolved({
-		absolutePath: params.resolved.absolutePath,
-		resolvedPath: params.resolved.resolvedPath,
-		rootRealPath: params.resolved.rootRealPath,
-		maxBytes: params.maxBytes,
-		rejectHardlinks: params.rejectHardlinks,
-		allowedType: params.allowedType,
-		ioFs: params.ioFs
-	});
-}
-function toBoundaryValidationError(error) {
-	return {
-		ok: false,
-		reason: "validation",
-		error
-	};
-}
-function mapResolvedBoundaryPath(absolutePath, resolved) {
-	return {
-		absolutePath,
-		resolvedPath: resolved.canonicalPath,
-		rootRealPath: resolved.rootCanonicalPath
-	};
-}
-function resolveBoundaryFilePathGeneric(params) {
-	const absolutePath = path.resolve(params.absolutePath);
-	try {
-		const resolved = params.resolve(absolutePath);
-		if (resolved instanceof Promise) return resolved.then((value) => mapResolvedBoundaryPath(absolutePath, value)).catch((error) => toBoundaryValidationError(error));
-		return mapResolvedBoundaryPath(absolutePath, resolved);
-	} catch (error) {
-		return toBoundaryValidationError(error);
-	}
-}
-//#endregion
-export { hasNodeErrorCode as a, isSymlinkOpenError as c, sameFileIdentity$1 as i, resolveBoundaryPathSync as l, matchBoundaryFileOpenFailure as n, isNotFoundPathError as o, openBoundaryFileSync as r, isPathInside as s, canUseBoundaryFileOpen as t };

package/dist/browser-lifecycle-cleanup-BdNsMhMD-O3tnAM4i.mjs

@@ -1,60 +0,0 @@
-import { n as loadBundledPluginPublicSurfaceModuleSync } from "./facade-loader-DFzIYYt_-CIr4HKtE.mjs";
-import "node:fs";
-import "node:path";
-import "node:os";
-//#region node_modules/.pnpm/openclaw@2026.4.22_@napi-rs+canvas@0.1.99/node_modules/openclaw/dist/browser-maintenance-CgzwL4B_.js
-let cachedBrowserMaintenanceSurface;
-function hasRequestedSessionKeys(sessionKeys) {
-	return sessionKeys.some((key) => Boolean(key?.trim()));
-}
-function loadBrowserMaintenanceSurface() {
-	cachedBrowserMaintenanceSurface ??= loadBundledPluginPublicSurfaceModuleSync({
-		dirName: "browser",
-		artifactBasename: "browser-maintenance.js"
-	});
-	return cachedBrowserMaintenanceSurface;
-}
-async function closeTrackedBrowserTabsForSessions(params) {
-	if (!hasRequestedSessionKeys(params.sessionKeys)) return 0;
-	let surface;
-	try {
-		surface = loadBrowserMaintenanceSurface();
-	} catch (error) {
-		params.onWarn?.(`browser cleanup unavailable: ${String(error)}`);
-		return 0;
-	}
-	return await surface.closeTrackedBrowserTabsForSessions(params);
-}
-//#endregion
-//#region node_modules/.pnpm/openclaw@2026.4.22_@napi-rs+canvas@0.1.99/node_modules/openclaw/dist/browser-lifecycle-cleanup-D8s47iQX.js
-async function runBestEffortCleanup(params) {
-	try {
-		return await params.cleanup();
-	} catch (error) {
-		params.onError?.(error);
-		return;
-	}
-}
-function normalizeSessionKeys(sessionKeys) {
-	const keys = /* @__PURE__ */ new Set();
-	for (const sessionKey of sessionKeys) {
-		const normalized = sessionKey.trim();
-		if (normalized) keys.add(normalized);
-	}
-	return [...keys];
-}
-async function cleanupBrowserSessionsForLifecycleEnd(params) {
-	const sessionKeys = normalizeSessionKeys(params.sessionKeys);
-	if (sessionKeys.length === 0) return;
-	await runBestEffortCleanup({
-		cleanup: async () => {
-			await closeTrackedBrowserTabsForSessions({
-				sessionKeys,
-				onWarn: params.onWarn
-			});
-		},
-		onError: params.onError
-	});
-}
-//#endregion
-export { cleanupBrowserSessionsForLifecycleEnd };