@poe-platform/safe-bash 0.1.756 → 0.1.757

package/dist/safe-bash/chunks/chunk-BMO5LWEX.js

@@ -1,534 +0,0 @@
-import {
-  init_platform
-} from "./chunk-ZG7GWQ5P.js";
-
-// packages/safe-bash/src/commands/python/invocation.ts
-init_platform();
-var PythonInvocationError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "PythonInvocationError";
-  }
-};
-function parsePythonInvocation(args, env) {
-  const startupArgs = [];
-  let informational = false;
-  scan: for (let index = 0; index < args.length; index++) {
-    const option = args[index];
-    if (option === "--" || option === "-" || !option.startsWith("-")) break;
-    if (option === "--help") {
-      informational = true;
-      break;
-    }
-    if (option === "--version") {
-      informational = true;
-      continue;
-    }
-    if (option.startsWith("--")) throw new PythonInvocationError("unsupported option " + option);
-    for (let offset = 1; offset < option.length; offset++) {
-      const flag = option[offset];
-      if (flag === "h" || flag === "?") {
-        informational = true;
-        break scan;
-      }
-      if (flag === "V") {
-        informational = true;
-        continue;
-      }
-      if ("cmWX".includes(flag)) {
-        const operand = option.slice(offset + 1) || args[++index];
-        if (operand === void 0) throw new PythonInvocationError("argument expected for -" + flag);
-        if (flag === "c" || flag === "m") break scan;
-        if (flag === "X") {
-          const separator = operand.indexOf("=");
-          const name = separator < 0 ? operand : operand.slice(0, separator);
-          const value = separator < 0 ? void 0 : operand.slice(separator + 1);
-          let decimal = value ?? "";
-          while (decimal.length && " 	\n\r\v\f".includes(decimal[0])) decimal = decimal.slice(1);
-          if (decimal[0] === "+" || decimal[0] === "-") decimal = decimal.slice(1);
-          const digits = decimal.length > 0 && [...decimal].every((character) => character >= "0" && character <= "9");
-          const supported = name === "utf8" && (value === void 0 || value === "0" || value === "1") || (name === "dev" || name === "warn_default_encoding") && value === void 0 || name === "int_max_str_digits" && digits && Number.isSafeInteger(Number(value)) && Number(value) <= 2147483647 && (Number(value) === 0 || Number(value) >= 640);
-          if (!supported) throw new PythonInvocationError("unsupported -X option " + operand);
-          startupArgs.push("-X", operand);
-        }
-        break;
-      }
-      if (!"BEPOusISbdvqR".includes(flag)) throw new PythonInvocationError("unsupported option -" + flag);
-      startupArgs.push("-" + flag);
-    }
-  }
-  if (!informational && !startupArgs.includes("-E") && !startupArgs.includes("-I")) {
-    if (env.PYTHONINSPECT) throw new PythonInvocationError("PYTHONINSPECT requires an interactive terminal, which the shell does not expose");
-    if (env.PYTHONHOME) throw new PythonInvocationError("PYTHONHOME cannot replace the configured Pyodide runtime");
-  }
-  const runtimeEnv = { ...env };
-  delete runtimeEnv.PYTHONPATH;
-  delete runtimeEnv.PYTHONHOME;
-  delete runtimeEnv.PYTHONWARNINGS;
-  runtimeEnv.PYTHONINSPECT = "";
-  startupArgs.push("-c", "");
-  return { startupArgs, env: runtimeEnv };
-}
-
-// packages/safe-bash/src/commands/python/diagnostics.ts
-init_platform();
-var messages = {
-  "executor-unavailable": "Python executor is unavailable; configure exactly one supported executor or interpreter worker.",
-  "transport-unavailable": "Python worker transport or shared-memory operations are unavailable.",
-  "runtime-abi": "Python runtime version or native ABI is unsupported.",
-  "runtime-assets": "Python runtime or package assets could not be loaded.",
-  "isolation-unavailable": "Python host isolation or resource enforcement is unavailable.",
-  deadline: "Python execution exceeded its host deadline.",
-  "filesystem-open": "Python filesystem handle access is unavailable; the backend must support retained open.",
-  "filesystem-read": "Python filesystem reads are unavailable for this backend.",
-  "filesystem-write": "Python filesystem writes are unavailable for this backend.",
-  "filesystem-directory": "Python retained directory operations are unavailable for this backend.",
-  "filesystem-operation": "The requested Python filesystem operation is unavailable for this backend.",
-  capacity: "Python worker capacity exhausted.",
-  cleanup: "Python resource cleanup failed; retirement could not be confirmed.",
-  startup: "Python startup failed; consult the host diagnostic callback.",
-  runtime: "Python runtime failed; consult the host diagnostic callback."
-};
-var PythonFailure = class extends Error {
-  constructor(category, options) {
-    super(messages[category], options);
-    this.category = category;
-    this.name = "PythonFailure";
-  }
-  category;
-};
-function isPythonFailureCategory(value) {
-  return typeof value === "string" && Object.hasOwn(messages, value);
-}
-function reportPythonFailure(category, cause, observer) {
-  const failure = new PythonFailure(category);
-  try {
-    void Promise.resolve(observer?.({ failure, cause })).catch(() => {
-    });
-  } catch {
-  }
-  return failure;
-}
-function inspectPythonCapabilities(options = {}) {
-  const failures = /* @__PURE__ */ new Set();
-  if (typeof options.createWorker === "function" === (typeof options.createExecutor === "function") || options.createWorker !== void 0 && typeof options.createWorker !== "function" || options.createExecutor !== void 0 && typeof options.createExecutor !== "function") failures.add("executor-unavailable");
-  if (typeof options.createExecutor !== "function" && (typeof SharedArrayBuffer !== "function" || typeof Atomics !== "object" || typeof Atomics.store !== "function" || typeof Atomics.notify !== "function")) failures.add("transport-unavailable");
-  if (options.runtimeVersion !== void 0 && options.runtimeVersion !== "314.0.6") failures.add("runtime-abi");
-  for (const requirement of options.requiredFileSystem ?? []) {
-    if (!["open", "read", "write", "directory"].includes(requirement)) throw new TypeError("Unknown Python filesystem requirement");
-    const category = requirement === "open" ? "filesystem-open" : requirement === "read" ? "filesystem-read" : requirement === "write" ? "filesystem-write" : "filesystem-directory";
-    try {
-      const fs = options.fs;
-      if (requirement === "directory") {
-        failures.add(category);
-      } else if (!fs || typeof fs.open !== "function" || fs.capabilities.open === false) failures.add("filesystem-open");
-      else if (requirement === "write" && (fs.capabilities.readOnly === true || fs.capabilities.write === false)) failures.add(category);
-      else if (requirement === "read" && fs.capabilities.read === false) failures.add(category);
-    } catch {
-      failures.add(category);
-    }
-  }
-  return Object.freeze({
-    configurationValid: failures.size === 0,
-    failures: Object.freeze([...failures].map((category) => new PythonFailure(category)))
-  });
-}
-
-// packages/safe-bash/src/commands/python/execution.ts
-init_platform();
-var pythonExecution = `
-import sys, os, json, runpy, traceback, types, warnings, textwrap, io, struct, linecache
-_safe_invocation = json.loads(_safe_invocation_json)
-os.environ.clear()
-os.environ.update(_safe_invocation['env'])
-_safe_args = list(_safe_invocation['args'])
-sys.orig_argv = [_safe_invocation.get('command', 'python')] + _safe_args
-_safe_exit = 0
-
-class _SafeOptionError(ValueError):
- pass
-
-def _safe_system_exit(_error):
- if isinstance(_error.code, int):
-  _status = int.__index__(_error.code)
-  _long_bound = 1 << (8 * struct.calcsize('@l') - 1)
-  status = (_status & 255) if -_long_bound <= _status < _long_bound else 255
- else:
-  status = 0 if _error.code is None else 1
- if _error.code is not None and not isinstance(_error.code, int):
-  print(_error.code, file=sys.stderr)
- return status
-
-def _safe_launch():
- args = list(_safe_args)
- unbuffered = False
- ignore_env = bool(sys.flags.ignore_environment)
- safe_path = bool(sys.flags.safe_path)
- native_warning_options = list(sys.warnoptions)
- # Pyodide adds a bootstrap cwd entry even when CPython safe-path mode is set.
- # Each execution mode below supplies its own entry after explicit PYTHONPATH.
- sys.path[:] = [entry for entry in sys.path if entry != '']
- warning_options = []
- version_count = 0
- options_terminated = False
- while args and args[0].startswith('-') and args[0] != '-':
-  option = args.pop(0)
-  if option == '--':
-   options_terminated = True
-   break
-  if option in ('--help', '-h', '-?'):
-   print('usage: python [-uBEPOsSIbdvqR] [-W filter] [-X option] [-c code | -m module | file | -] [args ...]')
-   print('Dedicated Pyodide interpreter; stdin is noninteractive.')
-   print('-u: unbuffered binary output; -B: disable bytecode writes; -E: ignore PYTHON* settings')
-   print('-P: omit automatic unsafe sys.path entry; -W: Python warning filter')
-   print('-O/-OO, -S/-s/-I, -b/-bb, -d/-v/-q/-R: CPython startup flags')
-   print('-X: utf8, dev, warn_default_encoding, int_max_str_digits; interactive flags are unsupported.')
-   return
-  if option == '--version':
-   version_count += 1
-   continue
-  if option.startswith('--'):
-   raise _SafeOptionError('unsupported option ' + option)
-  index = 1
-  while index < len(option):
-   flag = option[index]
-   if flag in ('h', '?'):
-    args = ['--help']
-    break
-   if flag == 'V':
-    version_count += 1
-    index += 1
-    continue
-   if flag in ('c', 'm', 'W', 'X'):
-    operand = option[index + 1:] if index + 1 < len(option) else args.pop(0) if args else None
-    if operand is None:
-     raise _SafeOptionError('argument expected for -' + flag)
-    if flag in ('W', 'X'):
-     if flag == 'W': warning_options.append(operand)
-     break
-    args = ['-' + flag, operand] + args
-    break
-   elif flag in ('O', 'S', 's', 'I', 'b', 'd', 'v', 'q', 'R'):
-    pass # Applied by CPython startup configuration before bootstrap.
-   elif flag == 'u':
-    unbuffered = True
-   elif flag == 'B':
-    sys.dont_write_bytecode = True
-   elif flag == 'E':
-    ignore_env = True
-   elif flag == 'P':
-    safe_path = True
-   else:
-    raise _SafeOptionError('unsupported option -' + flag)
-   index += 1
-  if args and args[0] in ('-c', '-m'):
-   break
- if version_count:
-  print('Python ' + (sys.version if version_count > 1 else sys.version.split()[0]))
-  return
- if not ignore_env:
-  unbuffered = unbuffered or bool(os.environ.get('PYTHONUNBUFFERED'))
-  sys.dont_write_bytecode = sys.dont_write_bytecode or bool(os.environ.get('PYTHONDONTWRITEBYTECODE'))
-  safe_path = safe_path or bool(os.environ.get('PYTHONSAFEPATH'))
-  path = os.environ.get('PYTHONPATH')
-  if path:
-   sys.path[0:0] = [os.path.abspath(entry) for entry in path.split(os.pathsep)]
-  if os.environ.get('PYTHONWARNINGS'):
-   warning_options[0:0] = os.environ['PYTHONWARNINGS'].split(',')
-  encoding = os.environ.get('PYTHONIOENCODING')
-  if encoding:
-   name, separator, errors = encoding.partition(':')
-   for stream in (sys.stdin, sys.stdout):
-    stream.reconfigure(encoding=name or None, errors=(errors or 'strict'))
-   sys.stderr.reconfigure(encoding=name or None, errors='backslashreplace')
- # CPython's -b/-bb filter follows environment and command-line -W filters.
- byte_warning = ('error' if sys.flags.bytes_warning > 1 else 'default') + '::BytesWarning'
- native_before = [value for value in native_warning_options if not (sys.flags.bytes_warning and value == byte_warning)]
- warning_options = native_before + warning_options + ([byte_warning] if sys.flags.bytes_warning else [])
- warnings._processoptions(warning_options)
- sys.warnoptions[:] = warning_options
- if unbuffered:
-  for name in ('stdout', 'stderr'):
-   stream = getattr(sys, name)
-   stream.flush()
-   encoding, errors = stream.encoding, stream.errors
-   binary = stream.detach()
-   raw = binary.detach() if hasattr(binary, 'detach') else binary
-   replacement = io.TextIOWrapper(raw, encoding=encoding, errors=errors, write_through=True)
-   setattr(sys, name, replacement)
-   setattr(sys, '__' + name + '__', replacement)
- main = types.ModuleType('__main__')
- main.__dict__.update(__package__=None, __spec__=None, __loader__=__import__('importlib.machinery', fromlist=['BuiltinImporter']).BuiltinImporter, __builtins__=__builtins__)
- sys.modules['__main__'] = main
- if not options_terminated and args and args[0] == '-c':
-  sys.argv = ['-c'] + args[2:]
-  if not safe_path: sys.path.insert(0, '')
-  source = textwrap.dedent(args[1])
-  code = compile(source, '<string>', 'exec')
-  # CPython 3.14 retains -c source for both top-level and nested tracebacks.
-  linecache._register_code(code, source, '<string>')
-  exec(code, main.__dict__)
- elif not options_terminated and args and args[0] == '-m':
-  sys.argv = args[1:]
-  if not safe_path: sys.path.insert(0, os.getcwd())
-  runpy._run_module_as_main(args[1], alter_argv=True)
- elif not args or args[0] == '-':
-  sys.argv = (['-'] + args[1:]) if args else ['']
-  if not safe_path: sys.path.insert(0, '')
-  main.__file__ = '<stdin>'
-  exec(compile(sys.stdin.buffer.read(), '<stdin>', 'exec'), main.__dict__)
- else:
-  sys.argv = args
-  # CPython makes __file__ absolute without collapsing ./ or ../ components.
-  path = args[0] if os.path.isabs(args[0]) else os.path.join(os.getcwd(), args[0])
-  importer = __import__('pkgutil').get_importer(path)
-  if importer is not None:
-   sys.path.insert(0, path)
-   runpy._run_module_as_main('__main__', alter_argv=False)
-  else:
-   if not safe_path: sys.path.insert(0, os.path.dirname(os.path.realpath(path)))
-   try:
-    with open(path, 'rb') as source:
-     code = source.read()
-   except OSError as error:
-    print("python: can't open file " + repr(path) + ': [Errno ' + str(error.errno) + '] ' + error.strerror, file=sys.stderr)
-    return 2
-   main.__file__ = path
-   main.__loader__ = __import__('importlib.machinery', fromlist=['SourceFileLoader']).SourceFileLoader('__main__', path)
-   exec(compile(code, path, 'exec'), main.__dict__)
- return 0
-
-try:
- _safe_exit = _safe_launch() or 0
-except SystemExit as _error:
- _safe_exit = _safe_system_exit(_error)
-except _SafeOptionError as _error:
- print('python: ' + str(_error), file=sys.stderr)
- _safe_exit = 2
-except BaseException as _error:
- # Hide bridge frames while preserving actual Python frames and chained errors.
- _trace = _error.__traceback__
- while _trace is not None and _trace.tb_frame.f_code.co_filename == '<exec>':
-  _trace = _trace.tb_next
- _error.__traceback__ = _trace
- sys.last_exc = _error
- _safe_exit = 130 if isinstance(_error, KeyboardInterrupt) else 1
- try:
-  sys.excepthook(type(_error), _error, _trace)
- except SystemExit as _hook_error:
-  _safe_exit = _safe_system_exit(_hook_error)
- except BaseException as _hook_error:
-  print('Error in sys.excepthook:', file=sys.stderr)
-  traceback.print_exception(type(_hook_error), _hook_error, _hook_error.__traceback__.tb_next)
-  print('\\nOriginal exception was:', file=sys.stderr)
-  sys.__excepthook__(type(_error), _error, _trace)
-finally:
- for _stream in (sys.stdout, sys.stderr):
-  if _stream is not None and not getattr(_stream, 'closed', False):
-   try:
-    _stream.flush()
-   except BaseException:
-    _safe_exit = 120
-_safe_exit
-`;
-
-// packages/safe-bash/src/commands/python/runtime-scripts.ts
-init_platform();
-var pythonRuntimeRelocation = `
-import sys, zipimport, importlib.machinery
-
-def _rebase_runtime_path(value):
- return _safe_runtime_mount + value if isinstance(value, str) and (value == '/lib' or value.startswith('/lib/')) else value
-
-def _rebase_runtime_loader(loader):
- if isinstance(loader, zipimport.zipimporter):
-  archive = _rebase_runtime_path(loader.archive)
-  if archive != loader.archive:
-   return zipimport.zipimporter(archive + '/' + loader.prefix)
- elif isinstance(loader, (importlib.machinery.SourceFileLoader, importlib.machinery.SourcelessFileLoader, importlib.machinery.ExtensionFileLoader)):
-  path = _rebase_runtime_path(loader.path)
-  if path != loader.path:
-   return type(loader)(loader.name, path)
- return loader
-sys.path[:] = [_rebase_runtime_path(value) for value in sys.path]
-for _module in list(sys.modules.values()):
- if _module is None:
-  continue
- for _attribute in ('__file__', '__cached__'):
-  if hasattr(_module, _attribute):
-   setattr(_module, _attribute, _rebase_runtime_path(getattr(_module, _attribute)))
- if hasattr(_module, '__path__'):
-  _module.__path__ = [_rebase_runtime_path(value) for value in _module.__path__]
- if hasattr(_module, '__loader__'):
-  _module.__loader__ = _rebase_runtime_loader(_module.__loader__)
- _spec = getattr(_module, '__spec__', None)
- if _spec is not None:
-  _spec.origin = _rebase_runtime_path(_spec.origin)
-  _spec.loader = _rebase_runtime_loader(_spec.loader)
-  if _spec.submodule_search_locations is not None:
-   _spec.submodule_search_locations = [_rebase_runtime_path(value) for value in _spec.submodule_search_locations]
-sys.path_importer_cache.clear()
-`;
-var pythonImportMetadata = `
-import importlib._bootstrap_external, types, json
-_safe_import_stat_callback = _safe_import_stat
-_safe_original_import_stat = importlib._bootstrap_external._path_stat
-def _safe_import_path_stat(path):
- if path == _safe_runtime_mount or path.startswith(_safe_runtime_mount + '/'):
-  return _safe_original_import_stat(path)
- value = json.loads(_safe_import_stat_callback(path))
- if 'errno' in value:
-  raise OSError(value['errno'], 'filesystem import metadata unavailable', path)
- return types.SimpleNamespace(st_mode=value['mode'], st_size=value['size'], st_mtime=value['mtimeMs'] / 1000)
-importlib._bootstrap_external._path_stat = _safe_import_path_stat
-`;
-var pythonDirectoryEntries = `
-import os, json, errno
-_safe_directory_callback = _safe_directory_entries
-def _safe_listdir(path='.'):
- if isinstance(path, int):
-  raise OSError(errno.ENOTSUP, 'retained directory descriptors are unsupported')
- original = os.fspath(path) if path is not None else '.'
- value = json.loads(_safe_directory_callback(os.fsdecode(original)))
- if 'errno' in value:
-  raise OSError(value['errno'], 'directory enumeration failed', path)
- return [os.fsencode(name) for name in value['entries']] if isinstance(original, bytes) else value['entries']
-os.listdir = _safe_listdir
-# The frozen importer holds the posix module separately from os.
-importlib._bootstrap_external._os.listdir = _safe_listdir
-`;
-var pythonStatProjection = `
-import os, json, errno
-_safe_stat_callback = _safe_stat_projection
-_safe_stat_type = os.stat_result
-_safe_fspath = os.fspath
-_safe_fsdecode = os.fsdecode
-
-def _safe_stat(path, *, dir_fd=None, follow_symlinks=True):
- if dir_fd is not None:
-  raise OSError(errno.ENOTSUP, 'dir_fd metadata is unsupported')
- if isinstance(path, int):
-  if not follow_symlinks:
-   raise ValueError('stat: cannot use fd and follow_symlinks together')
- else:
-  path = _safe_fsdecode(_safe_fspath(path))
- value = json.loads(_safe_stat_callback(path, follow_symlinks))
- if 'errno' in value:
-  raise OSError(value['errno'], 'filesystem metadata unavailable', path)
- keys = ('mode','ino','dev','nlink','uid','gid','size')
- if any(key not in value for key in keys):
-  raise OSError(errno.EOVERFLOW, 'canonical identity or required stat metadata unavailable', path)
- times = [value[key] / 1000 for key in ('atimeMs','mtimeMs','ctimeMs')]
- extras = dict(zip(('st_atime','st_mtime','st_ctime'), times))
- for name, milliseconds in zip(('atime','mtime','ctime'), (value['atimeMs'],value['mtimeMs'],value['ctimeMs'])):
-  seconds = int(milliseconds // 1000)
-  extras['st_' + name + '_ns'] = seconds * 1000000000 + round((milliseconds - seconds * 1000) * 1000000)
- for key in ('blocks','blksize','rdev'):
-  if key in value:
-   extras['st_' + key] = value[key]
- return _safe_stat_type(tuple(value[key] for key in keys) + tuple(int(time // 1) for time in times), extras)
-
-def _safe_lstat(path, *, dir_fd=None):
- return _safe_stat(path, dir_fd=dir_fd, follow_symlinks=False)
-
-def _safe_fstat(fd):
- if not isinstance(fd, int):
-  raise TypeError('file descriptor must be an integer')
- return _safe_stat(fd)
-os.stat = _safe_stat
-os.lstat = _safe_lstat
-os.fstat = _safe_fstat
-import stat as _safe_stat_module
-class _SafeDirEntry:
- def __init__(self, root, name):
-  self.name = name
-  self.path = os.path.join(root, name)
-  self._cache = {}
- def __fspath__(self):
-  return self.path
- def stat(self, *, follow_symlinks=True):
-  if follow_symlinks not in self._cache:
-   self._cache[follow_symlinks] = os.stat(self.path, follow_symlinks=follow_symlinks)
-  return self._cache[follow_symlinks]
- def inode(self):
-  return self.stat(follow_symlinks=False).st_ino
- def is_dir(self, *, follow_symlinks=True):
-  try:
-   return _safe_stat_module.S_ISDIR(self.stat(follow_symlinks=follow_symlinks).st_mode)
-  except FileNotFoundError:
-   return False
- def is_file(self, *, follow_symlinks=True):
-  try:
-   return _safe_stat_module.S_ISREG(self.stat(follow_symlinks=follow_symlinks).st_mode)
-  except FileNotFoundError:
-   return False
- def is_symlink(self):
-  try:
-   return _safe_stat_module.S_ISLNK(self.stat(follow_symlinks=False).st_mode)
-  except FileNotFoundError:
-   return False
-class _SafeScandir:
- def __init__(self, path):
-  self._entries = iter([_SafeDirEntry(path, name) for name in os.listdir(path)])
- def __iter__(self):
-  return self
- def __next__(self):
-  return next(self._entries)
- def close(self):
-  self._entries = iter(())
- def __enter__(self):
-  return self
- def __exit__(self, *args):
-  self.close()
-def _safe_scandir(path='.'):
- if isinstance(path, int):
-  raise OSError(errno.ENOTSUP, 'retained directory descriptors are unsupported')
- return _SafeScandir(os.fspath(path) if path is not None else '.')
-os.scandir = _safe_scandir
-
-`;
-var pythonHardLinks = `
-import os, json, errno
-_safe_link_callback = _safe_hard_link
-def _safe_link(src, dst, *, src_dir_fd=None, dst_dir_fd=None, follow_symlinks=True):
- if src_dir_fd is not None or dst_dir_fd is not None:
-  raise OSError(errno.ENOTSUP, 'dir_fd hard links are unsupported')
- source = os.fsdecode(os.fspath(src))
- destination = os.fsdecode(os.fspath(dst))
- value = json.loads(_safe_link_callback(source, destination, bool(follow_symlinks)))
- if 'errno' in value:
-  raise OSError(value['errno'], 'hard link creation failed', src, None, dst)
-os.link = _safe_link
-os.supports_follow_symlinks.add(_safe_link)
-`;
-var pythonTreeCleanup = `
-import shutil, os, json
-_safe_tree_callback = _safe_tree_cleanup
-_safe_original_rmtree_impl = shutil._rmtree_impl
-def _safe_rmtree_impl(path, dir_fd, onexc):
- if dir_fd is not None:
-  return _safe_original_rmtree_impl(path, dir_fd, onexc)
- value = json.loads(_safe_tree_callback(os.fsdecode(path)))
- if not value['supported']:
-  return _safe_original_rmtree_impl(path, dir_fd, onexc)
- if 'errno' in value:
-  onexc(os.rmdir, path, OSError(value['errno'], 'directory cleanup failed', path))
-shutil._rmtree_impl = _safe_rmtree_impl
-`;
-
-export {
-  PythonInvocationError,
-  parsePythonInvocation,
-  PythonFailure,
-  isPythonFailureCategory,
-  reportPythonFailure,
-  inspectPythonCapabilities,
-  pythonExecution,
-  pythonRuntimeRelocation,
-  pythonImportMetadata,
-  pythonDirectoryEntries,
-  pythonStatProjection,
-  pythonHardLinks,
-  pythonTreeCleanup
-};
-//# sourceMappingURL=chunk-BMO5LWEX.js.map