@poe-platform/safe-bash 0.1.823 → 0.1.824

package/dist/safe-bash/command-chunks/{chunk-LDR3PPM3.js → chunk-22QEL76N.js}

@@ -2,7 +2,7 @@ import {
   nodeFor,
   selected,
   validateSelection
-} from "./chunk-4HJEZGYN.js";
+} from "./chunk-YODHIRPW.js";
 import {
   Length
 } from "./chunk-GNVAW6NL.js";
@@ -11,10 +11,10 @@ import {
   child,
   loadShared,
   required
-} from "./chunk-UDRJKA3P.js";
+} from "./chunk-C23L4HZB.js";
 import {
   SelectionError
-} from "./chunk-SKF6PGA5.js";
+} from "./chunk-I2OKE2NI.js";
 import {
   OfficeError
 } from "./chunk-VJQ5OWS5.js";

package/dist/safe-bash/command-chunks/{chunk-BSLXS4PE.js → chunk-3DH5QBZC.js}

@@ -1,7 +1,7 @@
 import {
   attr,
   child
-} from "./chunk-UDRJKA3P.js";
+} from "./chunk-C23L4HZB.js";
 import {
   OfficeError
 } from "./chunk-VJQ5OWS5.js";

package/dist/safe-bash/command-chunks/{chunk-64HIOP7Q.js → chunk-3EBQOZET.js}

@@ -67,66 +67,29 @@ function parsePythonInvocation(args, env) {
   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
+// packages/safe-bash-command-python/src/package-program.generated.ts
+var pythonPackageProgramGzip = "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";
 
- 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)
+// packages/safe-bash-command-python/src/package-program.ts
+var decoded;
+function loadPythonPackageProgram() {
+  return decoded ??= new Response(new Blob([Uint8Array.from(atob(pythonPackageProgramGzip), (character) => character.charCodeAt(0))]).stream().pipeThrough(new DecompressionStream("gzip"))).text();
+}
 
- _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/native-wheel.generated.ts
+var pythonNativeWheelGzip = "H4sIAAAAAAACA51WTW/cNhC976+Y5iIJltWNgwSFYRVw0RTIoUnQGi3gYCHQ0mg1XYkUSMq7619f8ENaSl67aG7icGbe45vhUKsKaygUq7HAg5as1AVnmh6x2DeIbSyRVSkolMRaesIquV4Bdb2QGkgAUzC6k0jhHyV4aDPrFFQzaGpDu7OsoJaig57ppqWHMetXphvr+9n6mqV3fKK+phZHx3vqfzPLk+899WPOo6iomlyLnpU7tsWiFaxCGVJxlnlYVtc0hsqBF+rIyxn9Iy9XKyhbpibsv61aJzGyP9j+05dfmEKjGFiVC+KkiyJW2NYpKHpye2DWmVmm7rMXijQJDjk469pnMMVgDy3aDC5Woh4khzs5oHdSiLv/dNLYts8dZuhBOs9Y1LVCncK+QV5ivnaxVHsDcKGBOMTrFN6mcOW2QTJSCH+xdsCPUgoZR8QfWUuVD4sS4xac2cHAhU00o5SepEq+ueiNpzDF38A6xP3ypwO9ukoh+uSBmdwOHXLtoJeaBwKMwiw0MXUIqphfvh1l7Bhx4lvIoWOHib9xgss5kIM2G3kQR7WzkYLPgiMI6dY3sAZsFUJHPHZNMQXZTGLQ/aAhh4ejRiYlO8bWvm/MHWmRx84jgRub0WuEami1ZeBPFGg9Ql0G0Sl8eP/+3YfE5jZsG6aY1jJ2mVKIdIM88qU/5Q+vjvd1Kcpm4DtPW812qLYN5RyEtGewiwR+hiWvEW9W86neX4+6ERz8FHApXe29bhkeNPLK57cb8664yAP8oDEcbU9itZrOWQpe0zY4uBmFmRk2Kg6G6Qr2pJvzM8Sl+BaZo0abJBxATJYNPdoaUg0RcY1bSfoYmes3j3dX1M2yhikzaY2FtVshSTddCnjosdRYBWRH6FNie83KBsudGjrIx1QZx3085QoazlXtOl9SzmyjuR669g3gkmZDXzGNgcRUnzYbPFS0RaXjBH7IJ84vTZhFwadzQEeqY7psriGCC5gz9yWN3ryJvLAdalYxzQrOOnxJXPtydFRK0VOfjSGj5vYVLSpSuiBei6Ki2fMzIVQkp2SLh27xIt5T7x5FmDXPPfXxQuxZzzxR79Qy762p9el9jc+xiYPA9FlnzJXZJAn8CNHvH+9uf729u438bLFyzi5ANXS9iucHmQMpLWPDMElsqxQaDzpGXoqK+DaPBl1f/hTZ8TOGaSa3qF840ch3/LepSEYbW9vQ8ryybtjOfxKyLZoiKs3adqbQCOKYGDWe0cu6nYnomUSuVW5eYnPzTFuInV2GMe7/KCsGbjq48P2wLG+6wDAZvqcjqH5VOgPtq5ypoa7pAHkOUbZv2sh11EImhdr9PE799ErOFM72mTvRy30XbZJz0FN1mGYGQ30vcliN6shbelDBfAz6wW+eqc3/kvQM/iv3Z04sWb3y/+62QlPhfunPbDh6yepfGFf6SBQMAAA=";
+
+// packages/safe-bash-command-python/src/native-wheel.ts
+var decoded2;
+function loadPythonNativeWheel() {
+  return decoded2 ??= new Response(new Blob([Uint8Array.from(atob(pythonNativeWheelGzip), (character) => character.charCodeAt(0))]).stream().pipeThrough(new DecompressionStream("gzip"))).text();
+}
+
+// packages/safe-bash-command-python/src/package-url-hash.ts
+function pythonPackageUrlHash(url) {
+  const match = /(sha1|sha224|sha384|sha256|sha512|md5)=([a-f0-9]+)/.exec(url);
+  return match ? [match[1], match[2]] : void 0;
+}
 
 // packages/safe-bash-command-python/src/provisioning-runtime.ts
 async function installPythonPackages(supplied, start, request, maxTransferBytes) {
@@ -179,7 +142,7 @@ async function installPythonPackages(supplied, start, request, maxTransferBytes)
     try {
       runtime.globals.set(globals[0], read);
       runtime.globals.set(globals[1], JSON.stringify({ ...configuration, size }));
-      const result = JSON.parse(await runtime.runPythonAsync(pythonNativeWheel));
+      const result = JSON.parse(await runtime.runPythonAsync(await loadPythonNativeWheel()));
       if (Array.isArray(result)) for (const path of result) await runtime._api.loadDynlib(path);
       return result;
     } finally {
@@ -236,14 +199,16 @@ async function installPythonPackages(supplied, start, request, maxTransferBytes)
     installedGlobals.push(name);
   };
   try {
-    await loadPackages(["micropip"]);
+    await loadPackages(["micropip", ...start.bootstrapPackages ?? []]);
     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) => {
+    bind("_safe_package_wheel_download", async (url, expected) => withArtifact(url, expected, void 0, async (opened, read) => {
+      const hash = pythonPackageUrlHash(url);
+      if (hash) await wheel(opened.size, read, { integrity: hash });
       return JSON.stringify(await request("package-retain", start.session, opened.key));
     }));
     bind("_safe_package_wheel_metadata", async (serialized) => transfer(async () => {
@@ -279,303 +244,13 @@ async function installPythonPackages(supplied, start, request, maxTransferBytes)
       }
       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 runtime.runPythonAsync(await loadPythonPackageProgram());
     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")) });
+    await request("package-commit", start.session, start.restore === void 0 ? pinned : { version: 3, 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) {
@@ -724,6 +399,10 @@ def _safe_launch():
  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 sys.flags.no_site:
+  sys.argv = [args[0]] + args[2:] if not options_terminated and args and args[0] in ('-c', '-m') else args or ['']
+  import site
+  site.addsitepackages(site.addusersitepackages(None), [_safe_runtime_mount])
  if not options_terminated and args and args[0] == '-c':
   sys.argv = ['-c'] + args[2:]
   if not safe_path: sys.path.insert(0, '')
@@ -982,6 +661,7 @@ shutil._rmtree_impl = _safe_rmtree_impl
 export {
   PythonInvocationError,
   parsePythonInvocation,
+  pythonPackageUrlHash,
   installPythonPackages,
   pythonExecution,
   pythonRuntimeRelocation,

package/dist/safe-bash/command-chunks/{chunk-KQE2D7PX.js → chunk-3HUCLYKJ.js}

@@ -1,6 +1,6 @@
 import {
   validateColor
-} from "./chunk-75OUKYCM.js";
+} from "./chunk-CH5JDE3C.js";
 import {
   attr,
   child,
@@ -12,7 +12,7 @@ import {
   relPart,
   required,
   unique
-} from "./chunk-UDRJKA3P.js";
+} from "./chunk-C23L4HZB.js";
 import {
   parseXmlPart
 } from "./chunk-YWP62BAZ.js";

package/dist/safe-bash/command-chunks/{chunk-J4I7KCQQ.js → chunk-4JABZEDO.js}

@@ -1,6 +1,6 @@
 import {
   openRetainedPresentationIndex
-} from "./chunk-LZHFVNEV.js";
+} from "./chunk-S3QYSI5E.js";
 import {
   stageRetainedOutput,
   streamJson
@@ -10,13 +10,13 @@ import {
   child,
   invalid,
   loadShared
-} from "./chunk-UDRJKA3P.js";
+} from "./chunk-C23L4HZB.js";
 import {
   SelectionError
-} from "./chunk-SKF6PGA5.js";
+} from "./chunk-I2OKE2NI.js";
 import {
   openRetainedPresentationValidation
-} from "./chunk-SKDJCMGI.js";
+} from "./chunk-ATUZ7J3B.js";
 import {
   OfficeError,
   RetainedValues,

package/dist/safe-bash/command-chunks/{chunk-PVKSBXHB.js → chunk-4M6D4IUB.js}

@@ -1,6 +1,6 @@
 import {
   openRetainedPresentationIndex
-} from "./chunk-LZHFVNEV.js";
+} from "./chunk-S3QYSI5E.js";
 import {
   stageRetainedOutput,
   streamJson
@@ -14,13 +14,13 @@ import {
   nextRel,
   relPart,
   required
-} from "./chunk-UDRJKA3P.js";
+} from "./chunk-C23L4HZB.js";
 import {
   SelectionError
-} from "./chunk-SKF6PGA5.js";
+} from "./chunk-I2OKE2NI.js";
 import {
   openRetainedPresentationValidation
-} from "./chunk-SKDJCMGI.js";
+} from "./chunk-ATUZ7J3B.js";
 import {
   dialects
 } from "./chunk-P3LHQOX7.js";

package/dist/safe-bash/command-chunks/{chunk-UVM6QG2H.js → chunk-4MVQE6CT.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-52DDLGBS.js";
 import {
   boundedCodec
-} from "./chunk-RUXY7GN5.js";
+} from "./chunk-CMJBRGU2.js";
 
 // packages/safe-bash-compression-engine/src/zstd-decode.ts
 import { PublicDiagnostic } from "../../safe-bash-contracts/diagnostics.js";

package/dist/safe-bash/command-chunks/{chunk-QWQHLMDX.js → chunk-4VTB4DGE.js}

@@ -1,6 +1,6 @@
 import {
   requireLegacyCommentRemapping
-} from "./chunk-AR65HNNX.js";
+} from "./chunk-N2TN7IBE.js";
 import {
   attr,
   child,
@@ -9,11 +9,11 @@ import {
   loadShared,
   nextRel,
   relPart
-} from "./chunk-UDRJKA3P.js";
+} from "./chunk-C23L4HZB.js";
 import {
   SelectionError,
   decodeSelectionToken
-} from "./chunk-SKF6PGA5.js";
+} from "./chunk-I2OKE2NI.js";
 import {
   parseXmlPart
 } from "./chunk-YWP62BAZ.js";

package/dist/safe-bash/command-chunks/{chunk-JQPDVCBU.js → chunk-565AAQTV.js}

@@ -1,11 +1,11 @@
 import {
   nodeFor
-} from "./chunk-4HJEZGYN.js";
+} from "./chunk-YODHIRPW.js";
 import {
   TextFrame,
   applyFrameFormatting,
   readShape
-} from "./chunk-64L57DEI.js";
+} from "./chunk-UQTU7H6T.js";
 import {
   Length
 } from "./chunk-GNVAW6NL.js";
@@ -13,7 +13,7 @@ import {
   attr,
   child,
   required
-} from "./chunk-UDRJKA3P.js";
+} from "./chunk-C23L4HZB.js";
 import {
   parseXmlPart
 } from "./chunk-YWP62BAZ.js";

package/dist/safe-bash/command-chunks/{chunk-JSW6YH6T.js → chunk-5PRXCH54.js}

@@ -3,26 +3,26 @@ import {
   readShapePath,
   shapePathXml,
   validateShapePath
-} from "./chunk-BSLXS4PE.js";
+} from "./chunk-3DH5QBZC.js";
 import {
   addShape,
   nodeFor,
   selected,
   validateSelection
-} from "./chunk-4HJEZGYN.js";
+} from "./chunk-YODHIRPW.js";
 import {
   validateShapeOptions
-} from "./chunk-64L57DEI.js";
+} from "./chunk-UQTU7H6T.js";
 import {
   Length
 } from "./chunk-GNVAW6NL.js";
 import {
   loadShared,
   required
-} from "./chunk-UDRJKA3P.js";
+} from "./chunk-C23L4HZB.js";
 import {
   SelectionError
-} from "./chunk-SKF6PGA5.js";
+} from "./chunk-I2OKE2NI.js";
 import {
   OfficeError
 } from "./chunk-VJQ5OWS5.js";

package/dist/safe-bash/command-chunks/{chunk-42OQIFPW.js → chunk-5RLK2QSY.js}

@@ -1,3 +1,6 @@
+import {
+  playwrightStorageAbilities
+} from "./chunk-U6IEK2CI.js";
 import {
   playwrightTracingStart,
   playwrightTracingStop
@@ -9,9 +12,6 @@ import {
   playwrightRouteAbilities,
   setPlaywrightNetworkState
 } from "./chunk-PH6IMF5Z.js";
-import {
-  playwrightStorageAbilities
-} from "./chunk-HCJWEB6P.js";
 import {
   playwrightRecordingAbilities
 } from "./chunk-XPUHDPMZ.js";