@poe-platform/safe-bash 0.1.821 → 0.1.823

package/dist/safe-bash/command-chunks/chunk-64HIOP7Q.js

@@ -0,0 +1,993 @@
+// packages/safe-bash-command-python/src/invocation.ts
+var PythonInvocationError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "PythonInvocationError";
+  }
+};
+function parsePythonInvocation(args, env) {
+  const startupArgs = [];
+  let informational = false;
+  let module;
+  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 === "m" && !informational) module = { name: operand, args: args.slice(index + 1) };
+        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, module };
+}
+
+// packages/safe-bash-command-python/src/native-wheel.ts
+var pythonNativeWheel = `
+def _safe_extract_native_wheel(read, serialized):
+ import io as _native_io, json as _native_json, shutil as _native_shutil
+ from pathlib import Path as _NativePath
+ from zipfile import ZipFile as _NativeZip
+ from pyodide import _package_loader as _native_loader
+ from pyodide.ffi import run_sync as _native_sync
+
+ class _NativeWheel(_native_io.RawIOBase):
+  def __init__(self, size):
+   self.size, self.position = size, 0
+  def readable(self):
+   return True
+  def seekable(self):
+   return True
+  def tell(self):
+   return self.position
+  def seek(self, offset, whence=0):
+   if whence not in (0, 1, 2):
+    raise ValueError('invalid whence')
+   position = offset + (0, self.position, self.size)[whence]
+   if position < 0:
+    raise OSError(22, 'Invalid argument')
+   self.position = position
+   return position
+  def read(self, size=-1):
+   remaining = max(0, self.size - self.position)
+   size = remaining if size is None or size < 0 else min(size, remaining)
+   output = bytearray()
+   while len(output) < size:
+    result = read(self.position, min(size-len(output), 65536))
+    if hasattr(result, 'then'):
+     result = _native_sync(result)
+    chunk = bytes(result)
+    if not chunk or len(chunk) > size-len(output):
+     raise OSError('Invalid Python package chunk')
+    output.extend(chunk)
+    self.position += len(chunk)
+   return bytes(output)
+
+ _native_config = _native_json.loads(serialized)
+ with _NativeWheel(_native_config['size']) as _native_archive:
+  if 'metadata_name' in _native_config:
+   from micropip.metadata import wheel_dist_info_dir as _native_metadata_dir
+   from zipfile import Path as _NativeZipPath
+   with _NativeZip(_native_archive) as _native_zip:
+    path = _NativePath(_native_metadata_dir(_native_zip, _native_config['metadata_name'])) / 'METADATA'
+    return _native_json.dumps(_NativeZipPath(_native_zip, str(path)).read_text(encoding='utf-8'))
+  _native_target = _NativePath(_native_config['extract_dir'] if 'extract_dir' in _native_config else _native_loader.get_install_dir(_native_config['target']))
+  _native_target.mkdir(parents=True, exist_ok=True)
+  _native_shutil._unpack_zipfile(_native_archive, _native_target)
+  with _NativeZip(_native_archive) as _native_zip:
+   if _NativePath(_native_config['filename']).suffix == '.whl':
+    _native_loader.set_wheel_metadata(_native_config['filename'], _native_zip, _native_target, _native_config['metadata'])
+    _native_loader.install_datafiles(_native_config['filename'], _native_zip, _native_target)
+  _native_dynlibs = _native_loader.get_dynlibs(_native_archive, _NativePath(_native_config['filename']).suffix, _native_target)
+ return _native_json.dumps(_native_dynlibs)
+_safe_extract_native_wheel(_safe_native_wheel_read, _safe_native_wheel_config)
+`;
+
+// packages/safe-bash-command-python/src/provisioning-runtime.ts
+async function installPythonPackages(supplied, start, request, maxTransferBytes) {
+  if (!start.requirements.length && !start.uninstall && !start.bootstrap) return;
+  const runtime = supplied;
+  if (runtime.version !== "314.0.6" || !runtime._api?.packageManager || !runtime._api.lockfile_packages || typeof runtime._api.packageManager.installPackage !== "function" || typeof runtime.loadPackage !== "function" || typeof runtime.runPythonAsync !== "function") throw new Error("Python package installer ABI requires Pyodide 314.0.6");
+  let transportFailure;
+  let accepting = true;
+  let pending = Promise.resolve();
+  let installing = Promise.resolve();
+  const manager = runtime._api.packageManager;
+  const transfer = (consume) => {
+    if (!accepting) return Promise.reject(new Error("Python package transport is only available during installation"));
+    const work = pending.then(async () => {
+      if (transportFailure) throw transportFailure.error;
+      try {
+        return await consume();
+      } catch (error) {
+        transportFailure ??= { error };
+        throw error;
+      }
+    });
+    pending = work.then(() => {
+    }, () => {
+    });
+    return work;
+  };
+  const readArtifact = (operation, key, offset, length) => {
+    const failed = (error) => {
+      transportFailure ??= { error };
+      throw error;
+    };
+    try {
+      const result = request(operation, start.session, key, offset, Math.min(length, maxTransferBytes, 65536));
+      return result instanceof Promise ? result.catch(failed) : result;
+    } catch (error) {
+      return failed(error);
+    }
+  };
+  const withArtifact = (url, expected, metadata, consume) => transfer(async () => {
+    const opened = await request("package-open", start.session, url, expected, ...metadata ? [metadata] : []);
+    try {
+      return await consume(opened, (offset, length) => readArtifact("package-read", opened.key, offset, length));
+    } finally {
+      await request("package-close", start.session, opened.key);
+    }
+  });
+  const wheel = async (size, read, configuration) => {
+    const globals = ["_safe_native_wheel_read", "_safe_native_wheel_config", "_safe_extract_native_wheel"];
+    try {
+      runtime.globals.set(globals[0], read);
+      runtime.globals.set(globals[1], JSON.stringify({ ...configuration, size }));
+      const result = JSON.parse(await runtime.runPythonAsync(pythonNativeWheel));
+      if (Array.isArray(result)) for (const path of result) await runtime._api.loadDynlib(path);
+      return result;
+    } finally {
+      for (const name of globals) runtime.globals.delete(name);
+    }
+  };
+  const fetch = (url, expected, metadata) => withArtifact(url, expected, metadata, async (opened, read) => {
+    const bytes = new Uint8Array(opened.size);
+    for (let offset = 0; offset < bytes.length; ) {
+      const chunk = await read(offset, bytes.length - offset);
+      if (!Array.isArray(chunk) || chunk.length === 0 || offset + chunk.length > bytes.length) throw new Error("Invalid Python package chunk");
+      bytes.set(chunk, offset);
+      offset += chunk.length;
+    }
+    return { bytes, headers: opened.headers };
+  });
+  manager.downloadPackage = async (metadata) => {
+    if (!accepting) throw new Error("Python package transport is only available during installation");
+    if (metadata.channel === manager.defaultChannel) {
+      const pkg = runtime._api.lockfile_packages[metadata.normalizedName];
+      if (!pkg) throw new Error(`Missing matching Pyodide package: ${metadata.normalizedName}`);
+      return { url: new URL(pkg.file_name, "https://cdn.jsdelivr.net/pyodide/v314.0.6/full/").href, expected: pkg.sha256 };
+    }
+    return { url: metadata.channel };
+  };
+  manager.installPackage = (metadata, source) => {
+    if (!accepting) return Promise.reject(new Error("Python package transport is only available during installation"));
+    const work = installing.then(async () => {
+      if (source instanceof Uint8Array) throw new Error("Expected retained Python package source");
+      const pkg = runtime._api.lockfile_packages[metadata.normalizedName] ?? metadata.packageData;
+      if (!pkg) throw new Error(`Missing matching Pyodide package: ${metadata.normalizedName}`);
+      return withArtifact(source.url, source.expected, void 0, (opened, read) => wheel(opened.size, read, {
+        filename: pkg.file_name,
+        target: pkg.install_dir ?? null,
+        metadata: { INSTALLER: "pyodide.loadPackage", PYODIDE_SOURCE: metadata.channel === manager.defaultChannel ? "pyodide" : metadata.channel }
+      }));
+    });
+    installing = work.then(() => {
+    }, () => {
+    });
+    return work;
+  };
+  const loadPackages = async (names) => {
+    const errors = [];
+    await runtime.loadPackage(names, { messageCallback() {
+    }, errorCallback(message) {
+      errors.push(message);
+    } });
+    if (errors.length) throw new Error(errors.join("\n"));
+  };
+  const installedGlobals = [];
+  const bind = (name, value) => {
+    runtime.globals.set(name, value);
+    installedGlobals.push(name);
+  };
+  try {
+    await loadPackages(["micropip"]);
+    bind("_safe_package_native", loadPackages);
+    bind("_safe_package_bytes", async (url, hash) => (await fetch(url, hash)).bytes);
+    bind("_safe_package_metadata", async (url) => {
+      const result = await fetch(url, void 0, "metadata");
+      return JSON.stringify({ text: new TextDecoder().decode(result.bytes), headers: Object.fromEntries(result.headers.map(([name, value]) => [name.toLowerCase(), value])) });
+    });
+    bind("_safe_package_wheel_download", async (url, expected) => withArtifact(url, expected, void 0, async (opened) => {
+      return JSON.stringify(await request("package-retain", start.session, opened.key));
+    }));
+    bind("_safe_package_wheel_metadata", async (serialized) => transfer(async () => {
+      const { source, name } = JSON.parse(serialized);
+      return wheel(source.size, (offset, length) => readArtifact("package-read-retained", source.token, offset, length), { metadata_name: name });
+    }));
+    bind("_safe_package_wheel_install", async (serialized) => transfer(async () => {
+      const { source, ...configuration } = JSON.parse(serialized);
+      await wheel(source.size, (offset, length) => readArtifact("package-read-retained", source.token, offset, length), configuration);
+    }));
+    bind("_safe_package_requirements_json", JSON.stringify(start.requested ?? start.requirements));
+    for (const key of ["pre", "upgrade", "forceReinstall", "legacy"]) {
+      bind("_safe_package_" + key, !!start[key]);
+    }
+    bind("_safe_package_restore_json", JSON.stringify(start.restore ?? []));
+    bind("_safe_package_records_json", JSON.stringify(start.records ?? null));
+    bind("_safe_package_uninstall_json", JSON.stringify(start.uninstall ?? null));
+    bind("_safe_package_emit", async (stream, message) => {
+      if (stream !== "stdout" && stream !== "stderr") throw new Error("Invalid package output stream");
+      const bytes = new TextEncoder().encode(message);
+      for (let offset = 0; offset < bytes.length; offset += maxTransferBytes) await request(stream, Array.from(bytes.subarray(offset, offset + maxTransferBytes)));
+    });
+    bind("_safe_package_line", async () => {
+      const bytes = [];
+      while (true) {
+        const chunk = await request("stdin", 1);
+        if (!chunk.length) {
+          if (!bytes.length) throw new Error("EOF when reading package confirmation");
+          break;
+        }
+        if (chunk[0] === 10) break;
+        bytes.push(chunk[0]);
+      }
+      return new TextDecoder().decode(Uint8Array.from(bytes));
+    });
+    await runtime.runPythonAsync(`
+import json as _safe_json
+import importlib.metadata as _safe_metadata
+_safe_preloaded = [d.metadata['Name'] for d in _safe_metadata.distributions() if d.metadata['Name']]
+from micropip._compat import compatibility_layer as _safe_compat
+from micropip.package_manager import PackageManager as _SafePackageManager
+from micropip.wheelinfo import WheelInfo as _SafeWheelInfo
+from micropip._utils import check_compatible as _safe_check_compatible
+from micropip._vendored.packaging.src.packaging.requirements import Requirement as _SafeRequirement, InvalidRequirement as _SafeInvalidRequirement
+from micropip._vendored.packaging.src.packaging.utils import canonicalize_name as _safe_name
+
+class _SafePackageCompatibility(_safe_compat):
+ @staticmethod
+ async def loadPackage(names):
+  return await _safe_package_native(names)
+ @staticmethod
+ async def fetch_bytes(url, kwargs):
+  return (await _safe_package_bytes(url)).to_bytes()
+ @staticmethod
+ async def fetch_string_and_headers(url, kwargs):
+  value = _safe_json.loads(await _safe_package_metadata(url))
+  return value['text'], value['headers']
+
+async def _safe_wheel_fetch(self, url, kwargs, compat):
+ expected = self.sha256 if url == self.url else None
+ if url == self.metadata_url and isinstance(self.core_metadata, dict):
+  expected = self.core_metadata.get('sha256')
+ return (await _safe_package_bytes(url, expected)).to_bytes()
+_SafeWheelInfo._fetch_bytes = _safe_wheel_fetch
+from micropip.metadata import Metadata as _SafeWheelMetadata
+async def _safe_wheel_download(self, fetch_kwargs, compat_layer):
+ if self._data is not None:
+  return
+ self._data = _safe_json.loads(await _safe_package_wheel_download(self.url, self.sha256))
+ if self._metadata is None:
+  metadata = await _safe_package_wheel_metadata(_safe_json.dumps({'source': self._data, 'name': self.name}))
+  self._metadata = _SafeWheelMetadata(metadata.encode('utf-8'))
+async def _safe_wheel_install(self, target, compat_layer):
+ if not self._data:
+  raise RuntimeError('Micropip internal error: attempted to install wheel before downloading it?')
+ source = 'pypi' if self.sha256 is not None else self.url
+ metadata = {'PYODIDE_SOURCE': source, 'PYODIDE_URL': self.url, 'PYODIDE_SHA256': self._data['key'], 'INSTALLER': 'micropip'}
+ if self._requires:
+  metadata['PYODIDE_REQUIRES'] = _safe_json.dumps(sorted(x.name for x in self._requires))
+ await _safe_package_wheel_install(_safe_json.dumps({'source': self._data, 'filename': self.filename, 'extract_dir': str(target), 'metadata': metadata}))
+ setattr(compat_layer.loadedPackages, self._project_name, source)
+_SafeWheelInfo.download = _safe_wheel_download
+_SafeWheelInfo.install = _safe_wheel_install
+_safe_preloaded = {_safe_name(name) for name in _safe_preloaded}
+_safe_manager = _SafePackageManager(_SafePackageCompatibility)
+async def _safe_parse_sources(sources, download=True):
+ roots = []
+ for source in sources:
+  try:
+   root = _SafeRequirement(source)
+   if root.name.endswith('.whl'):
+    raise _SafeInvalidRequirement(source)
+  except _SafeInvalidRequirement:
+   wheel = _SafeWheelInfo.from_url(source)
+   root = _SafeRequirement(wheel.name + ' @ ' + source)
+  roots.append(root)
+  if (not root.marker or root.marker.evaluate({'extra': ''})) and root.url:
+   direct = _SafeWheelInfo.from_url(root.url)
+   _safe_check_compatible(direct.filename)
+   if download:
+    await direct.download({}, _SafePackageCompatibility)
+ return roots
+
+def _safe_validate(roots):
+ for root in roots:
+  if root.marker and not root.marker.evaluate({'extra': ''}):
+   continue
+  version = _safe_metadata.version(root.name)
+  if not root.specifier.contains(version, prereleases=True):
+   raise ValueError('Python package version conflict: ' + str(root))
+  if root.url:
+   wheel = _SafeWheelInfo.from_url(root.url)
+   pin = _SafeRequirement(wheel.name + '==' + str(wheel.version))
+   if _safe_name(wheel.name) != _safe_name(root.name) or not pin.specifier.contains(version, prereleases=True):
+    raise ValueError('Python package wheel version conflict: ' + str(root))
+async def _safe_resolve(_safe_roots, upgrade=False, force=False):
+ _safe_extras = {}
+ for _safe_root in _safe_roots:
+  if not _safe_root.marker or _safe_root.marker.evaluate({'extra': ''}):
+   _safe_extras.setdefault(_safe_name(_safe_root.name), set()).update(_safe_root.extras)
+ for _safe_root in _safe_roots:
+  _safe_root.extras.update(_safe_extras.get(_safe_name(_safe_root.name), set()))
+ _safe_requested_names = set(_safe_extras)
+ import micropip.package_manager as _safe_pm
+ _SafeTransaction = _safe_pm.Transaction
+ class _SafeReplacementTransaction(_SafeTransaction):
+  def check_version_satisfied(self, req, *, allow_reinstall=False):
+   if req.url:
+    wheel = _SafeWheelInfo.from_url(req.url)
+    if _safe_name(wheel.name) != req.name:
+     raise ValueError('Python package wheel name conflict: ' + str(req))
+    req = _SafeRequirement(req.name + '==' + str(wheel.version))
+   if req.name in _safe_preloaded or req.name in self.locked:
+    return super().check_version_satisfied(req)
+   if force or (upgrade and req.name in _safe_requested_names):
+    return False, ''
+   return super().check_version_satisfied(req, allow_reinstall=allow_reinstall)
+ async def _safe_install(requirements):
+  _safe_pm.Transaction = _SafeReplacementTransaction
+  try:
+   await _safe_manager.install(requirements, deps=True, pre=_safe_package_pre, reinstall=True)
+  finally:
+   _safe_pm.Transaction = _SafeTransaction
+ _safe_validate([root for root in _safe_roots if _safe_name(root.name) in _safe_preloaded])
+ await _safe_install([str(root) for root in _safe_roots])
+ _safe_managed = set(_safe_requested_names)
+ _safe_previous_pending = set()
+ while True:
+  _safe_distributions = [d for d in _safe_metadata.distributions() if d.metadata['Name']]
+  _safe_versions = {_safe_name(d.metadata['Name']): d.version for d in _safe_distributions}
+  while True:
+   _safe_changed = False
+   _safe_dependencies = []
+   for _safe_dist in _safe_distributions:
+    if _safe_name(_safe_dist.metadata['Name']) not in _safe_managed:
+     continue
+    _safe_contexts = {''} | _safe_extras.get(_safe_name(_safe_dist.metadata['Name']), set())
+    for _safe_dep in _safe_dist.requires or []:
+     _safe_requirement = _SafeRequirement(_safe_dep)
+     if _safe_requirement.marker and not any(_safe_requirement.marker.evaluate({'extra': extra}) for extra in _safe_contexts):
+      continue
+     _safe_requirement.marker = None
+     _safe_dependencies.append(_safe_requirement)
+     _safe_dependency_name = _safe_name(_safe_requirement.name)
+     if _safe_dependency_name not in _safe_managed:
+      _safe_managed.add(_safe_dependency_name)
+      _safe_changed = True
+     _safe_selected = _safe_extras.setdefault(_safe_name(_safe_requirement.name), set())
+     if not _safe_requirement.extras.issubset(_safe_selected):
+      _safe_selected.update(_safe_requirement.extras)
+      _safe_changed = True
+   if not _safe_changed:
+    break
+  _safe_pending = set()
+  for _safe_requirement in _safe_dependencies:
+   _safe_version = _safe_versions.get(_safe_name(_safe_requirement.name))
+   if _safe_version is None or not _safe_requirement.specifier.contains(_safe_version, prereleases=True):
+    _safe_pending.add(str(_safe_requirement))
+  if not _safe_pending:
+   break
+  if frozenset(_safe_pending) in _safe_previous_pending:
+   raise ValueError('Python package dependencies remain missing: ' + ', '.join(sorted(_safe_pending)))
+  _safe_previous_pending.add(frozenset(_safe_pending))
+  await _safe_install(sorted(_safe_pending))
+ _safe_validate(_safe_roots)
+ return _safe_managed
+def _safe_removal_listing(_safe_dist):
+ from micropip._utils import get_files_in_distribution as _safe_distribution_files
+ import os as _safe_os
+ def _safe_compact(paths):
+  compact = []
+  for path in sorted(paths, key=len):
+   if not any(path.startswith(parent.rstrip('*').rstrip('/') + '/') for parent in compact):
+    compact.append(path)
+  return compact
+ _safe_files = {str(path) for path in _safe_distribution_files(_safe_dist) if not str(path).endswith('.pyc')}
+ _safe_folders = _safe_compact({_safe_os.path.dirname(path) for path in _safe_files if path.endswith('__init__.py') or '.dist-info' in path})
+ _safe_skipped = set()
+ for _safe_folder in _safe_folders:
+  for _safe_dir, _, _safe_names in _safe_os.walk(_safe_folder):
+   for _safe_name_ in _safe_names:
+    _safe_path = _safe_os.path.join(_safe_dir, _safe_name_)
+    if not _safe_name_.endswith('.pyc') and _safe_os.path.isfile(_safe_path) and _safe_path not in _safe_files:
+     _safe_skipped.add(_safe_path)
+ _safe_listing = set(_safe_files) | {_safe_os.path.join(folder, '*') for folder in _safe_folders}
+ return [sorted(_safe_compact(_safe_listing)), sorted(_safe_compact(_safe_skipped))]
+_safe_uninstall = _safe_json.loads(_safe_package_uninstall_json)
+_safe_records = _safe_json.loads(_safe_package_records_json)
+_safe_metadata_only = _safe_uninstall is not None and _safe_records is not None
+_safe_record_by_name = {}
+_safe_snapshot_paths = {}
+if _safe_records is not None:
+ for _safe_record in _safe_records:
+  _safe_record_name = _safe_record[0]
+  if _SafeRequirement(_safe_record_name).name != _safe_record_name or _safe_name(_safe_record_name) != _safe_record_name or _safe_record_name in _safe_record_by_name:
+   raise ValueError('Invalid Python package metadata snapshot')
+  _safe_record_by_name[_safe_record_name] = _safe_record
+if _safe_metadata_only:
+ from pathlib import Path as _SafePath
+ import sysconfig as _safe_sysconfig
+ for _safe_record_name, _safe_record in _safe_record_by_name.items():
+  if _safe_record_name in _safe_preloaded:
+   continue
+  _safe_path = (_SafePath(_safe_sysconfig.get_path('purelib')) / (_safe_record_name.replace('-', '_') + '-snapshot.dist-info')).resolve()
+  _safe_path.mkdir()
+  (_safe_path / 'METADATA').write_text(_safe_record[1])
+  (_safe_path / 'PYODIDE_URL').write_text(_safe_record[2])
+  (_safe_path / 'RECORD').write_text('')
+  _safe_dist = _safe_metadata.Distribution.at(_safe_path)
+  if _safe_name(_safe_dist.metadata['Name']) != _safe_record_name:
+   raise ValueError('Python package metadata name conflict: ' + _safe_record_name)
+  _SafeRequirement(_safe_record_name + '==' + _safe_dist.version)
+  _safe_snapshot_paths[_safe_record_name] = str(_safe_path)
+ _safe_metadata.MetadataPathFinder.invalidate_caches()
+_safe_restore = _safe_json.loads(_safe_package_restore_json)
+_safe_restored_roots = await _safe_parse_sources(_safe_restore, not _safe_metadata_only)
+if _safe_package_legacy:
+ _safe_restored_names = await _safe_resolve(_safe_restored_roots)
+else:
+ if not _safe_metadata_only:
+  await _safe_manager.install(_safe_restore, deps=False)
+ _safe_validate(_safe_restored_roots)
+ _safe_restored_names = {_safe_name(root.name) for root in _safe_restored_roots if not root.marker or root.marker.evaluate({'extra': ''})}
+if _safe_metadata_only and set(_safe_record_by_name) != _safe_restored_names:
+ raise ValueError('Python package metadata snapshot does not match installed requirements')
+_safe_roots = await _safe_parse_sources(_safe_json.loads(_safe_package_requirements_json), not _safe_metadata_only)
+if _safe_metadata_only:
+ for _safe_root in _safe_roots:
+  if _safe_root.url and _safe_name(_safe_root.name) in _safe_snapshot_paths:
+   _safe_wheel = _SafeWheelInfo.from_url(_safe_root.url)
+   if _safe_name(_safe_wheel.name) == _safe_name(_safe_root.name) and str(_safe_wheel.version) == _safe_metadata.version(_safe_root.name):
+    _safe_root.url = None
+    _safe_root.specifier = _SafeRequirement(_safe_root.name + '==' + str(_safe_wheel.version)).specifier
+_safe_managed = await _safe_resolve(_safe_roots, _safe_package_upgrade, _safe_package_forceReinstall)
+_safe_distributions = [d for d in _safe_metadata.distributions() if d.metadata['Name']]
+_safe_versions = {_safe_name(d.metadata['Name']): d.version for d in _safe_distributions}
+_safe_removed = []
+if _safe_uninstall:
+ _safe_targets = list(dict.fromkeys(_safe_name(_SafeRequirement(source).name) for source in _safe_uninstall['packages']))
+ for _safe_target in _safe_targets:
+  if _safe_target in _safe_preloaded or _safe_target in _safe_managed:
+   raise ValueError('Cannot uninstall host-required Python package: ' + _safe_target)
+ for _safe_target in _safe_targets:
+  if _safe_target not in _safe_versions:
+   await _safe_package_emit('stderr', 'WARNING: Skipping ' + _safe_target + ' as it is not installed.\\n')
+   continue
+  _safe_dist = _safe_metadata.distribution(_safe_target)
+  _safe_version = _safe_dist.version
+  await _safe_package_emit('stdout', 'Found existing installation: ' + _safe_target + ' ' + _safe_version + '\\nUninstalling ' + _safe_target + '-' + _safe_version + ':\\n')
+  if not _safe_uninstall['yes']:
+   _safe_record = _safe_record_by_name.get(_safe_target)
+   _safe_lists = _safe_record[3:] if _safe_snapshot_paths.get(_safe_target) == str(_safe_dist._path) else _safe_removal_listing(_safe_dist)
+   for _safe_heading, _safe_paths in zip(['Would remove:', 'Would not remove (might be manually added):'], _safe_lists):
+    if _safe_paths:
+     await _safe_package_emit('stdout', '  ' + _safe_heading + '\\n')
+     for _safe_path in _safe_paths:
+      await _safe_package_emit('stdout', '    ' + _safe_path + '\\n')
+   while True:
+    await _safe_package_emit('stdout', 'Proceed (Y/n)? ')
+    _safe_answer = (await _safe_package_line()).strip().lower()
+    if _safe_answer in ('y', 'n', ''):
+     break
+    await _safe_package_emit('stdout', 'Your response (' + repr(_safe_answer) + ') was not one of the expected responses: y, n, \\n')
+   if _safe_answer == 'n':
+    continue
+  import logging as _safe_logging
+  _safe_logger = _safe_logging.getLogger('micropip')
+  _safe_disabled = _safe_logger.disabled
+  try:
+   _safe_logger.disabled = True
+   _safe_manager.uninstall([_safe_target])
+  finally:
+   _safe_logger.disabled = _safe_disabled
+  _safe_metadata.MetadataPathFinder.invalidate_caches()
+  try:
+   _safe_metadata.distribution(_safe_target)
+  except _safe_metadata.PackageNotFoundError:
+   pass
+  else:
+   raise ValueError('Python package removal did not complete: ' + _safe_target)
+  _safe_restored_names.discard(_safe_target)
+  _safe_removed.append(_safe_target + '-' + _safe_version)
+ _safe_distributions = [d for d in _safe_metadata.distributions() if d.metadata['Name']]
+ _safe_versions = {_safe_name(d.metadata['Name']): d.version for d in _safe_distributions}
+_safe_uninstalled_json = _safe_json.dumps(_safe_removed)
+_safe_managed.update(_safe_restored_names)
+_safe_sources = []
+_safe_final_records = []
+for _safe_dist in _safe_distributions:
+ _safe_dist_name = _safe_name(_safe_dist.metadata['Name'])
+ if _safe_dist_name in _safe_managed:
+  _safe_origin = _safe_dist.read_text('PYODIDE_URL')
+  if _safe_origin:
+   _safe_sources.append(_safe_dist_name + ' @ ' + _safe_origin.strip())
+  if _safe_snapshot_paths.get(_safe_dist_name) == str(_safe_dist._path):
+   _safe_final_records.append(_safe_record_by_name[_safe_dist_name])
+  else:
+   _safe_headers = _safe_dist.metadata
+   _safe_metadata_text = ''.join(key + ': ' + value + '\\n' for key in ['Metadata-Version', 'Name', 'Version', 'Requires-Python', 'Requires-Dist', 'Provides-Extra'] for value in _safe_headers.get_all(key, []))
+   _safe_final_records.append([_safe_dist_name, _safe_metadata_text, (_safe_origin or '').strip(), *_safe_removal_listing(_safe_dist)])
+_safe_installed_json = _safe_json.dumps(_safe_sources + [name + '==' + version for name, version in sorted(_safe_versions.items()) if name in _safe_managed])
+_safe_records_json = _safe_json.dumps(_safe_final_records)
+_safe_metadata.MetadataPathFinder.invalidate_caches()
+import gc as _safe_gc
+_safe_gc.collect()
+`);
+    await installing;
+    accepting = false;
+    await pending;
+    if (transportFailure) throw transportFailure.error;
+    const pinned = JSON.parse(runtime.runPython("_safe_installed_json"));
+    await request("package-commit", start.session, start.restore === void 0 ? pinned : { version: 2, installed: pinned, records: JSON.parse(runtime.runPython("_safe_records_json")) });
+    if (start.uninstall) {
+      const removed = JSON.parse(runtime.runPython("_safe_uninstalled_json"));
+      for (const name of removed) {
+        const bytes = new TextEncoder().encode("  Successfully uninstalled " + name + "\n");
+        for (let offset = 0; offset < bytes.length; offset += maxTransferBytes) await request("stdout", Array.from(bytes.subarray(offset, offset + maxTransferBytes)));
+      }
+    }
+  } catch (error) {
+    await installing;
+    accepting = false;
+    await pending;
+    throw transportFailure ? transportFailure.error : error;
+  } finally {
+    await installing;
+    accepting = false;
+    await pending;
+    manager.downloadPackage = manager.installPackage = async () => {
+      throw new Error("Python package transport is only available during installation");
+    };
+    for (const name of installedGlobals) runtime.globals.delete(name);
+  }
+}
+
+// packages/safe-bash-command-python/src/execution.ts
+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-command-python/src/runtime-scripts.ts
+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,
+  installPythonPackages,
+  pythonExecution,
+  pythonRuntimeRelocation,
+  pythonImportMetadata,
+  pythonDirectoryEntries,
+  pythonStatProjection,
+  pythonHardLinks,
+  pythonTreeCleanup
+};