@poe-platform/safe-bash 0.1.823 → 0.1.825

package/dist/safe-bash/command-chunks/{chunk-WDTWJFPK.js → chunk-RZOHZGEZ.js}

@@ -1,54 +1,16 @@
+import {
+  openPythonPackageFile
+} from "./chunk-NXCJNPL3.js";
+
+// packages/safe-bash-command-python/src/build-wheel.ts
+import { FsError as FsError2 } from "../../safe-bash-contracts/index.js";
+import { resolvePath as resolvePath2, basename } from "../../safe-bash-contracts/path.js";
+
 // packages/safe-bash-command-python/src/package-download.ts
 import { FsError } from "../../safe-bash-contracts/index.js";
 import { resolvePath } from "../../safe-bash-contracts/path.js";
 import { interruptible } from "../../safe-bash-contracts/runtime-control.js";
-import { yieldTurn as yieldTurn2 } from "../../safe-bash-contracts/yield.js";
-
-// packages/safe-bash-command-python/src/package-file.ts
 import { yieldTurn } from "../../safe-bash-contracts/yield.js";
-import { sha256 } from "@noble/hashes/sha2.js";
-import { compareIdentity, compareFileVersion } from "@poe-platform/safe-fs/core";
-async function openPythonPackageFile({ fs, signal }, path, maxBytes, expected) {
-  const settings = { signal };
-  const capabilities = await fs.capabilitiesFor?.(path, settings) ?? fs.capabilities;
-  if (!capabilities.retainedRead || !fs.openReadFile) return void 0;
-  const file = await fs.openReadFile(path, settings);
-  try {
-    signal.throwIfAborted();
-    const state = { ...await file.stat(settings) };
-    if (expected && (compareIdentity(expected, state) !== "same" || !compareFileVersion(expected, state))) throw new Error("Canonical Python wheel changed");
-    if (state.type !== "file" || !Number.isSafeInteger(state.size) || state.size < 0) throw new Error("Invalid canonical Python wheel");
-    if (state.size > maxBytes) throw new Error("Canonical package exceeds maxDownloadBytes");
-    const check = async () => {
-      signal.throwIfAborted();
-      const current = await file.stat(settings);
-      if (compareIdentity(state, current) !== "same" || !compareFileVersion(state, current)) throw new Error("Canonical Python wheel changed");
-    };
-    const read = async (offset, length) => {
-      await check();
-      const count = Math.min(length, Math.max(0, state.size - offset));
-      if (!count) return new Uint8Array(0);
-      const bytes = Uint8Array.from(await file.read(offset, count, settings));
-      if (!bytes.length || bytes.length > count) throw new Error("Invalid canonical package read");
-      await check();
-      return bytes;
-    };
-    const hash = sha256.create();
-    for (let offset = 0, pulls = 0; offset < state.size; ) {
-      if (++pulls % 16 === 0) await yieldTurn(signal);
-      const bytes = await read(offset, 65536);
-      hash.update(bytes);
-      offset += bytes.length;
-    }
-    await check();
-    return { key: Array.from(hash.digest(), (byte) => byte.toString(16).padStart(2, "0")).join(""), size: state.size, read, close: () => file.close() };
-  } catch (error) {
-    await file.close();
-    throw error;
-  }
-}
-
-// packages/safe-bash-command-python/src/package-download.ts
 var serial = 0;
 async function stagePythonPackage(context, directory, body, maxBytes, progress, verify, publish) {
   const { fs, signal } = context, settings = { signal };
@@ -103,7 +65,7 @@ async function stagePythonPackage(context, directory, body, maxBytes, progress,
           const chunk = Uint8Array.from(bytes.subarray(offset, offset + 65536));
           await owner.writer.write(chunk, settings);
           count += chunk.length;
-          await yieldTurn2(signal);
+          await yieldTurn(signal);
         }
         if (bytes.length) progress(count);
       }
@@ -145,9 +107,67 @@ async function stagePythonPackage(context, directory, body, maxBytes, progress,
   }
 }
 
+// packages/safe-bash-command-python/src/build-wheel.ts
+async function publishPythonBuildWheel(source, directory, maxBytes, context) {
+  const { fs, signal } = context, settings = { signal };
+  let artifact = typeof source === "string" ? void 0 : source.artifact;
+  let reading;
+  try {
+    signal.throwIfAborted();
+    if (maxBytes !== Infinity && (!Number.isSafeInteger(maxBytes) || maxBytes < 0)) throw new RangeError("Invalid Python wheel size limit");
+    const filename = typeof source === "string" ? basename(source) : source.filename;
+    if (basename(filename) !== filename || !filename.endsWith(".whl") || filename.includes("\\") || filename.includes("\0")) throw new TypeError("Invalid Python build wheel filename");
+    const root = await fs.realpath(resolvePath2(context.cwd, directory), settings);
+    const caps = await fs.capabilitiesFor?.(root, settings) ?? fs.capabilities;
+    if (!fs.confineExtraction || !fs.prepareDirectory || !caps.retainedStagingWrite || !caps.retainedStagingCleanup || !caps.retainedRead || !caps.atomicFileStaging) throw new Error("Python wheel publication requires confined retained atomic staging");
+    if (typeof source === "string") artifact = await openPythonPackageFile(context, resolvePath2(context.cwd, source), maxBytes);
+    if (!artifact) throw new Error("Python wheel publication requires retained source reads");
+    if (artifact.size > maxBytes) throw new Error("Canonical package exceeds maxDownloadBytes");
+    const retained = artifact;
+    const confined = await fs.confineExtraction([root], settings);
+    const destination = new Proxy(confined, { get(target, key) {
+      const owner = key === "openReadFile" ? fs : target, value = Reflect.get(owner, key);
+      return typeof value === "function" ? value.bind(owner) : value;
+    } });
+    const parent = await destination.stat(root, settings), path = resolvePath2(root, artifact.key);
+    try {
+      await destination.prepareDirectory(path, { parent, expected: null, mode: 448, signal });
+    } catch (error) {
+      if (!(error instanceof FsError2) || !["EEXIST", "EAGAIN"].includes(error.code)) throw error;
+    }
+    if ((await destination.lstat(path, settings)).type !== "directory") throw new Error("Python wheel publication directory changed");
+    const output = resolvePath2(path, filename);
+    const body = async function* () {
+      for (let offset = 0; offset < retained.size; ) {
+        const bytes = await (reading = Promise.resolve(retained.read(offset, Math.min(65536, retained.size - offset))));
+        if (!bytes.length || bytes.length > Math.min(65536, retained.size - offset)) throw new Error("Invalid Python wheel read");
+        offset += bytes.length;
+        yield bytes;
+      }
+    };
+    const published = await stagePythonPackage({ ...context, fs: destination }, path, body(), maxBytes, () => {
+    }, (key) => {
+      if (key !== retained.key) throw new Error("Built Python wheel integrity mismatch");
+    }, () => output);
+    if (!published) throw new Error("Python wheel publication requires retained atomic staging");
+    try {
+      return { url: "file://" + output.split("/").map(encodeURIComponent).join("/"), digest: published.key, size: published.size };
+    } finally {
+      await published.close();
+    }
+  } finally {
+    try {
+      await reading?.catch(() => {
+      });
+    } finally {
+      await artifact?.close?.();
+    }
+  }
+}
+
 // packages/safe-bash-command-python/src/provisioning.ts
-import { sha256 as sha2562 } from "@noble/hashes/sha2.js";
-import { resolvePath as resolve, dirname } from "../../safe-bash-contracts/path.js";
+import { sha256 } from "@noble/hashes/sha2.js";
+import { resolvePath as resolve, dirname, basename as basename2 } from "../../safe-bash-contracts/path.js";
 import { inheritYieldCheckpoint } from "../../safe-bash-contracts/yield.js";
 
 // packages/safe-bash-command-python/src/manifest.ts
@@ -155,9 +175,9 @@ function readPackageManifest(value) {
   const strings = (values) => Array.isArray(values) && values.every((item) => typeof item === "string");
   if (Array.isArray(value)) return strings(value) ? value : void 0;
   if (!value || typeof value !== "object") return;
-  const record = value;
-  if (![1, 2].includes(record.version) || Object.keys(value).length !== record.version + 1) return;
-  if (record.version === 2 && (!Array.isArray(record.records) || !record.records.every((row) => Array.isArray(row) && row.length === 5 && row.every((part, index) => index < 3 ? typeof part === "string" : strings(part))))) return;
+  const record = value, version = record.version;
+  if (![1, 2, 3].includes(version) || Object.keys(value).length !== (version === 1 ? 2 : 3)) return;
+  if (version !== 1 && (!Array.isArray(record.records) || !record.records.every((row) => Array.isArray(row) && row.length === version + 3 && row.every((part, index) => index > 2 && index < 5 ? strings(part) : typeof part === "string" || index === 5 && part === null)))) return;
   return strings(record.installed) ? record.installed : void 0;
 }
 var PythonPackageConflictError = class extends Error {
@@ -271,7 +291,7 @@ var pythonDocumentPackages = Object.freeze([
 var encoder = new TextEncoder();
 var decoder = new TextDecoder();
 function digest(value) {
-  return Array.from(sha2562(value), (byte) => byte.toString(16).padStart(2, "0")).join("");
+  return Array.from(sha256(value), (byte) => byte.toString(16).padStart(2, "0")).join("");
 }
 function validDigest(value) {
   if (typeof value !== "string" || value.length !== 64) return false;
@@ -307,8 +327,8 @@ function createPythonPackageEnvironment(options = {}) {
     const value = options[name];
     if (value !== void 0 && (!Number.isSafeInteger(value) || value < 1)) throw new RangeError(`${name} must be a positive integer`);
   }
-  const cacheRecord = (key, headers) => {
-    const bytes = encoder.encode(JSON.stringify({ digest: key, headers }));
+  const cacheRecord = (key, headers, url) => {
+    const bytes = encoder.encode(JSON.stringify({ digest: key, headers, url }));
     if (bytes.length > maxMetadataBytes) throw failure("Python package cache metadata exceeds maxMetadataBytes");
     return bytes;
   };
@@ -353,18 +373,20 @@ function createPythonPackageEnvironment(options = {}) {
     const context = { ...input, signal };
     signal.throwIfAborted();
     const directory = options.cacheDirectory === void 0 ? void 0 : resolve(context.cwd, options.cacheDirectory, pythonPackageRuntimeKey);
-    const cache = options.cache ?? (directory === void 0 ? defaultCache : {
+    const noCache = context.noCache ?? options.noCache ?? false;
+    const artifactDirectory = directory ?? (!options.cache && !noCache ? resolve(context.cwd, ".python-packages", "cache", pythonPackageRuntimeKey) : void 0);
+    const cache = options.cache ?? (artifactDirectory === void 0 ? defaultCache : {
       async get(key) {
         try {
-          return await context.fs.readFile(resolve(directory, key), { signal });
+          return await context.fs.readFile(resolve(artifactDirectory, key), { signal });
         } catch (error) {
           if (missing(error)) return void 0;
           throw error;
         }
       },
       async set(key, bytes) {
-        await context.fs.mkdir(directory, { recursive: true, signal });
-        await context.fs.writeFile(resolve(directory, key), bytes, { signal });
+        await context.fs.mkdir(artifactDirectory, { recursive: true, signal });
+        await context.fs.writeFile(resolve(artifactDirectory, key), bytes, { signal });
       }
     });
     const manifestCache = options.cacheDirectory === void 0 ? defaultCache : cache;
@@ -405,13 +427,15 @@ function createPythonPackageEnvironment(options = {}) {
         throw failure(`Cannot read Python requirements ${path}: ${error instanceof Error ? error.message : String(error)}`);
       }
       for (const line of source.split("\n")) {
-        const comment = line.split("").findIndex((character, index) => character === "#" && (index === 0 || line[index - 1].trim() === ""));
+        let comment = line.indexOf("#");
+        while (comment > 0 && line[comment - 1].trim()) comment = line.indexOf("#", comment + 1);
         const text = (comment < 0 ? line : line.slice(0, comment)).trim();
         if (!text) continue;
-        if (text.endsWith("\\") || text.startsWith("-")) throw failure(`Unsupported requirements option or continuation in ${path}: ${text}`);
-        requirements.push(normalizeRequirement(text, dirname(path)));
+        if (text.endsWith("\\")) throw failure(`Unsupported requirements continuation in ${path}: ${text}`);
+        requirements.push(text[0] === "-" && options.prepareRequirements ? text : normalizeRequirement(text, dirname(path)));
       }
     }
+    if ((options.editable?.length || context.editable?.length) && !options.prepareRequirements) throw failure("Editable packages require a source package environment");
     const requested = [...new Set(await options.prepareRequirements?.(requirements, context) ?? requirements)];
     signal.throwIfAborted();
     const session = String(++counter);
@@ -424,7 +448,7 @@ function createPythonPackageEnvironment(options = {}) {
       }
     };
     const offline = context.offline ?? options.offline ?? false;
-    sessions.set(session, { ...context, cacheDirectory: directory, noCache: context.noCache ?? options.noCache ?? false, cache, manifestCache, manifestRevision, controller: invocation, offline, requirements: unique, opening: false, retained: /* @__PURE__ */ new Map(), closed: false, manifest, aborted });
+    sessions.set(session, { ...context, cacheDirectory: directory, artifactDirectory, noCache, cache, manifestCache, manifestRevision, controller: invocation, offline, requirements: unique, opening: false, retained: /* @__PURE__ */ new Map(), closed: false, manifest, aborted });
     signal.addEventListener("abort", aborted, { once: true });
     const controls = {};
     for (const key of ["pre", "upgrade", "forceReinstall"]) if (context[key] ?? options[key]) controls[key] = true;
@@ -474,42 +498,85 @@ function createPythonPackageEnvironment(options = {}) {
       return Array.from(bytes);
     }
     if (op === "package-retain") {
-      const artifact = session.opened;
+      let artifact = session.opened;
       if (!artifact || artifact.key !== String(args[1])) throw failure("Invalid package retention request");
+      if (artifact.url && artifact.close) {
+        const source = artifact;
+        const retaining = (async () => {
+          const path = decodeURIComponent(new URL(source.url).pathname);
+          const directory = resolve(session.cacheDirectory ?? resolve(session.cwd, ".python-packages"), "installed");
+          const capabilities = await session.fs.capabilitiesFor?.(directory, { signal: session.signal }) ?? session.fs.capabilities;
+          if (!session.fs.confineExtraction || !session.fs.prepareDirectory || !capabilities.retainedStagingWrite || !capabilities.retainedStagingCleanup || !capabilities.retainedRead || !capabilities.atomicFileStaging) return;
+          const target = resolve(directory, source.key, basename2(path));
+          if (path !== target) {
+            await session.fs.mkdir(directory, { recursive: true, signal: session.signal });
+            checkSession(session);
+            session.opened = void 0;
+            const published = await publishPythonBuildWheel({ filename: basename2(path), artifact: source }, directory, maxBytes, session);
+            artifact = await openPythonPackageFile(session, decodeURIComponent(new URL(published.url).pathname), maxBytes);
+            if (!artifact) throw failure("Installed Python wheels require retained reads");
+            if (artifact.key !== published.digest) {
+              await artifact.close?.();
+              throw failure("Installed Python wheel changed");
+            }
+            session.opened = artifact;
+            artifact.url = published.url;
+            try {
+              checkSession(session);
+            } catch (error) {
+              await release(session);
+              throw error;
+            }
+          }
+          const durable = new URL(artifact.url);
+          durable.hash = "sha256=" + artifact.key;
+          artifact.url = durable.href;
+        })();
+        session.retaining = retaining;
+        try {
+          await retaining;
+        } finally {
+          session.retaining = void 0;
+        }
+      }
+      checkSession(session);
+      if (!artifact) throw failure("Installed Python wheel unavailable");
       const token = String(++counter);
       session.retained.set(token, artifact);
       session.opened = void 0;
-      return { token, key: artifact.key, size: artifact.size };
+      return { token, key: artifact.key, size: artifact.size, ...artifact.url ? { url: artifact.url } : {} };
     }
     if (op === "package-close") {
       if (session.opened?.key === String(args[1])) await release(session);
       return null;
     }
     if (op !== "package-open" || typeof args[1] !== "string") throw failure("Invalid package operation");
-    if (session.opening) throw failure("Package download already in progress");
+    if (session.opening || session.retaining) throw failure("Package download already in progress");
     session.opening = true;
     try {
       await release(session);
       checkSession(session);
-      const url = args[1];
+      const url = args[1], { artifactDirectory: cacheDirectory, noCache } = session;
       const expected = args[2];
+      let responseUrl = url;
       const verifyIntegrity = (key2) => {
         if (expected && key2 !== expected) throw failure(`Package integrity mismatch: ${url}`);
       };
       if (expected !== void 0 && expected !== null && !validDigest(expected)) throw failure("Invalid SHA-256 package integrity value");
       const address = pythonPackageRuntimeKey + "-url-" + digest(encoder.encode(url));
       const canonicalWheel = url.startsWith("file:") || url.startsWith("emfs:");
-      const metadata = canonicalWheel || session.noCache || args[3] === "metadata" && !session.offline ? void 0 : await session.cache.get(address);
+      const metadata = canonicalWheel || noCache || args[3] === "metadata" && !session.offline ? void 0 : await session.cache.get(address);
       checkSession(session);
       let key = "", bytes;
       let headers = [];
       const adopt = async (artifact, ready) => {
         session.opened = artifact;
+        if (canonicalWheel) artifact.url = url;
         try {
           checkSession(session);
           await ready();
           checkSession(session);
-          return { key: artifact.key, size: artifact.size, headers };
+          return { key: artifact.key, size: artifact.size, headers, url: responseUrl };
         } catch (error) {
           await release(session);
           throw error;
@@ -522,13 +589,14 @@ function createPythonPackageEnvironment(options = {}) {
           record = JSON.parse(decoder.decode(metadata));
         } catch {
         }
-        if (typeof record !== "object" || record === null || !validDigest(record.digest) || !Array.isArray(record.headers) || record.headers.some((pair) => !Array.isArray(pair) || pair.length !== 2 || pair.some((value2) => typeof value2 !== "string"))) throw failure(`Invalid package cache metadata: ${url}`);
+        if (typeof record !== "object" || record === null || !validDigest(record.digest) || record.url !== void 0 && typeof record.url !== "string" || !Array.isArray(record.headers) || record.headers.some((pair) => !Array.isArray(pair) || pair.length !== 2 || pair.some((value2) => typeof value2 !== "string"))) throw failure(`Invalid package cache metadata: ${url}`);
         headers = record.headers;
+        responseUrl = record.url ?? url;
         let absent = false;
-        if (session.cacheDirectory) {
+        if (cacheDirectory) {
           let artifact;
           try {
-            artifact = await openPythonPackageFile(session, resolve(session.cacheDirectory, pythonPackageRuntimeKey + "-sha256-" + record.digest), maxBytes);
+            artifact = await openPythonPackageFile(session, resolve(cacheDirectory, pythonPackageRuntimeKey + "-sha256-" + record.digest), maxBytes);
           } catch (error) {
             if (!missing(error)) throw error;
             absent = true;
@@ -591,14 +659,15 @@ function createPythonPackageEnvironment(options = {}) {
               }
               if (response.status < 200 || response.status >= 300) throw failure(`Package download failed: HTTP ${response.status} ${current.href}`);
               headers = response.headers;
+              responseUrl = current.href;
               const encoding = headers.find(([key2]) => key2.toLowerCase() === "content-encoding")?.[1].trim().toLowerCase();
               const length = headers.find(([key2]) => key2.toLowerCase() === "content-length")?.[1];
               const total = length === void 0 || encoding !== void 0 && encoding !== "identity" ? void 0 : Number(length);
               if (total !== void 0 && Number.isFinite(total) && total > maxBytes) throw failure("Package download exceeds maxDownloadBytes");
               const progress = (count2) => options.onProgress?.({ phase: "download", url, bytes: count2, ...typeof total === "number" && Number.isSafeInteger(total) ? { totalBytes: total } : {} });
-              if (session.cacheDirectory || session.noCache) {
-                const directory = session.cacheDirectory ?? session.cwd;
-                if (session.cacheDirectory) await session.fs.mkdir(directory, { recursive: true, signal: session.signal });
+              if (cacheDirectory || noCache) {
+                const directory = cacheDirectory ?? session.cwd;
+                if (cacheDirectory) await session.fs.mkdir(directory, { recursive: true, signal: session.signal });
                 let metadataBytes;
                 const artifact = await stagePythonPackage(
                   session,
@@ -608,13 +677,13 @@ function createPythonPackageEnvironment(options = {}) {
                   progress,
                   (key2) => {
                     verifyIntegrity(key2);
-                    if (!session.noCache) metadataBytes = cacheRecord(key2, headers);
+                    if (!noCache) metadataBytes = cacheRecord(key2, headers, responseUrl);
                   },
-                  session.noCache ? void 0 : (key2) => resolve(directory, pythonPackageRuntimeKey + "-sha256-" + key2)
+                  noCache ? void 0 : (key2) => resolve(directory, pythonPackageRuntimeKey + "-sha256-" + key2)
                 );
                 if (artifact) {
                   return await adopt(artifact, async () => {
-                    if (!session.noCache) await session.cache.set(address, metadataBytes);
+                    if (!noCache) await session.cache.set(address, metadataBytes);
                   });
                 }
               }
@@ -642,8 +711,8 @@ function createPythonPackageEnvironment(options = {}) {
         }
         checkSession(session);
         verifyIntegrity(key = digest(bytes));
-        if (!session.noCache) {
-          const metadataBytes = cacheRecord(key, headers);
+        if (!noCache) {
+          const metadataBytes = cacheRecord(key, headers, responseUrl);
           await session.cache.set(pythonPackageRuntimeKey + "-sha256-" + key, Uint8Array.from(bytes));
           checkSession(session);
           if (!canonicalWheel) await session.cache.set(address, metadataBytes);
@@ -652,8 +721,8 @@ function createPythonPackageEnvironment(options = {}) {
       checkSession(session);
       verifyIntegrity(key);
       const value = bytes;
-      session.opened = { key, size: bytes.length, read: (offset, length) => value.subarray(offset, offset + length) };
-      return { key, size: bytes.length, headers };
+      session.opened = { key, size: bytes.length, ...canonicalWheel ? { url } : {}, read: (offset, length) => value.subarray(offset, offset + length) };
+      return { key, size: bytes.length, headers, url: responseUrl };
     } finally {
       session.opening = false;
     }
@@ -668,7 +737,14 @@ function createPythonPackageEnvironment(options = {}) {
         session.signal.removeEventListener("abort", session.aborted);
         session.controller.abort(failure("Python package session is closed"));
         sessions.delete(start.session);
-        return release(session, true);
+        const retired = release(session, true);
+        return Promise.allSettled([session.retaining, retired]).then(async () => {
+          try {
+            await retired;
+          } finally {
+            await release(session, true);
+          }
+        });
       }
     },
     dispose() {
@@ -687,8 +763,7 @@ function createPythonPackageEnvironment(options = {}) {
 }
 
 export {
-  openPythonPackageFile,
-  stagePythonPackage,
+  publishPythonBuildWheel,
   PythonPackageConflictError,
   createPythonPackageManifestStore,
   createPythonPackageCache,

package/dist/safe-bash/command-chunks/{chunk-3MFYCMQU.js → chunk-S2T7DDGY.js}

@@ -1,7 +1,7 @@
 import {
   validateXmlPartReplacement,
   validateXmlViewReplacement
-} from "./chunk-OMD45J52.js";
+} from "./chunk-MW3L6JB7.js";
 import {
   createPresentation
 } from "./chunk-2GUI3ZKE.js";
@@ -11,42 +11,42 @@ import {
   indexed,
   preservePlaceholder,
   reparentInsertedAsset
-} from "./chunk-PYYAX5FB.js";
+} from "./chunk-63WEGFLL.js";
 import {
   Chart,
   insertChartIntoState,
   inspectWorkbook,
   replaceChartData
-} from "./chunk-2VSNIHIW.js";
+} from "./chunk-APUXNXXQ.js";
 import {
   createLiveLinkSession,
   isOrdinaryLinkUrl
-} from "./chunk-WV3C6BRD.js";
+} from "./chunk-MHZ7UTRX.js";
 import {
   addOleObject
-} from "./chunk-FGK6HLSY.js";
+} from "./chunk-QC2RWSYM.js";
 import {
   applyPresentationCanvasSettings
-} from "./chunk-ZZ6EIACJ.js";
+} from "./chunk-VGHRMAI4.js";
 import {
   prepareSlideInsertion
-} from "./chunk-XXUMECE4.js";
+} from "./chunk-DEEZYCOQ.js";
 import {
   Image
 } from "./chunk-ZXIOTUXC.js";
 import {
   addMedia
-} from "./chunk-NNYOPI7K.js";
+} from "./chunk-7NF44M2V.js";
 import {
   addImage
-} from "./chunk-HQFX5XKV.js";
+} from "./chunk-RB7XAYO2.js";
 import {
   CoreProperties,
   createPropertyPart
-} from "./chunk-6REH56FL.js";
+} from "./chunk-AA254KE5.js";
 import {
   readShape
-} from "./chunk-64L57DEI.js";
+} from "./chunk-UQTU7H6T.js";
 import {
   createXmlElementView
 } from "./chunk-RKON2TGI.js";
@@ -60,26 +60,26 @@ import {
   loadShared,
   relPart,
   required
-} from "./chunk-UDRJKA3P.js";
+} from "./chunk-C23L4HZB.js";
 import {
   writePackageArchive
 } from "./chunk-5KWEZV5H.js";
 import {
   buildSelectionIndex
-} from "./chunk-SKF6PGA5.js";
+} from "./chunk-I2OKE2NI.js";
 import {
   readPackage
 } from "./chunk-KVTZJBLM.js";
 import {
   parseXmlPart
 } from "./chunk-YWP62BAZ.js";
+import {
+  parseContentTypes
+} from "./chunk-6ZHNKHQQ.js";
 import {
   parseRelationships,
   readRelationshipGraph
 } from "./chunk-QMXOKYMJ.js";
-import {
-  parseContentTypes
-} from "./chunk-6ZHNKHQQ.js";
 import {
   packageUri,
   partName,

package/dist/safe-bash/command-chunks/{chunk-LZHFVNEV.js → chunk-S3QYSI5E.js}

@@ -12,7 +12,7 @@ import {
   diagramContentTypes,
   diagramRelationshipKinds,
   prepareSelectionQuery
-} from "./chunk-SKF6PGA5.js";
+} from "./chunk-I2OKE2NI.js";
 import {
   dialects,
   openRetainedCompatibility

package/dist/safe-bash/command-chunks/{chunk-ZLMCWAAU.js → chunk-STTXZKR6.js}

@@ -1,14 +1,14 @@
 import {
   readTextBodies,
   validateTextReadingOptions
-} from "./chunk-FCGMSOF6.js";
+} from "./chunk-P6YTNXRV.js";
 import {
   loadShared
-} from "./chunk-UDRJKA3P.js";
+} from "./chunk-C23L4HZB.js";
 import {
   SelectionError,
   readSelectionIndex
-} from "./chunk-SKF6PGA5.js";
+} from "./chunk-I2OKE2NI.js";
 import {
   readPackage
 } from "./chunk-KVTZJBLM.js";

package/dist/safe-bash/command-chunks/{chunk-AXUHORS3.js → chunk-SUYSZJI3.js}

@@ -1,6 +1,6 @@
 import {
   playwrightStandardAbilities
-} from "./chunk-42OQIFPW.js";
+} from "./chunk-5RLK2QSY.js";
 import {
   limitedForms,
   playwrightBuiltinCommands

package/dist/safe-bash/command-chunks/{chunk-C5SLY3RB.js → chunk-U2C6A3QO.js}

@@ -1,7 +1,7 @@
 import {
   openRetainedMedia,
   readMedia
-} from "./chunk-ZTW2E5OT.js";
+} from "./chunk-WAE3OCOU.js";
 import {
   readPackage
 } from "./chunk-KVTZJBLM.js";

package/dist/safe-bash/command-chunks/{chunk-HCJWEB6P.js → chunk-U6IEK2CI.js}

@@ -1,3 +1,10 @@
+import {
+  readPlaywrightStorageState,
+  replacePlaywrightStorageState
+} from "./chunk-SRXARACJ.js";
+import {
+  parsePlaywrightStorageStateJson
+} from "./chunk-YMZQFL3O.js";
 import {
   capabilityArtifact,
   capabilityResult,
@@ -6,13 +13,6 @@ import {
   requireSession,
   unsupported
 } from "./chunk-MI4J3AIL.js";
-import {
-  readPlaywrightStorageState,
-  replacePlaywrightStorageState
-} from "./chunk-3TP4SSPS.js";
-import {
-  parsePlaywrightStorageStateJson
-} from "./chunk-YMZQFL3O.js";
 import {
   PlaywrightResourceLimitError
 } from "./chunk-I6ICC6AG.js";

package/dist/safe-bash/command-chunks/{chunk-NN6OWOJG.js → chunk-UC6DUY3K.js}

@@ -1,12 +1,12 @@
 import {
   sanitizeProperties
-} from "./chunk-6REH56FL.js";
+} from "./chunk-AA254KE5.js";
 import {
   attr,
   invalid,
   loadShared,
   relPart
-} from "./chunk-UDRJKA3P.js";
+} from "./chunk-C23L4HZB.js";
 import {
   readPackage
 } from "./chunk-KVTZJBLM.js";

package/dist/safe-bash/command-chunks/{chunk-64L57DEI.js → chunk-UQTU7H6T.js}

@@ -2,18 +2,18 @@ import {
   MSO_AUTO_SHAPE_TYPE,
   shapePresets
 } from "./chunk-RC4TNFNF.js";
+import {
+  MSO_LANGUAGE_ID
+} from "./chunk-ZZKJPLIH.js";
 import {
   createXmlElementView
 } from "./chunk-RKON2TGI.js";
-import {
-  MSO_LANGUAGE_ID
-} from "./chunk-LBBJ5S3W.js";
 import {
   readRunFormatting,
   runPropertiesMerge,
   textUnderlineStyles,
   validateTextRunOptions
-} from "./chunk-U6VSRO6E.js";
+} from "./chunk-WNVBS4GV.js";
 import {
   bestFitText
 } from "./chunk-RESJSUHH.js";
@@ -22,7 +22,7 @@ import {
   applyDrawingUpdate,
   readDrawingColor,
   readDrawingFormat
-} from "./chunk-NDJPULBE.js";
+} from "./chunk-CEKBIZGU.js";
 import {
   ColorFormat,
   MSO_COLOR_TYPE,
@@ -33,11 +33,11 @@ import {
   defineEnum,
   defineXmlEnum,
   readRunColor
-} from "./chunk-3RDEX4AF.js";
+} from "./chunk-PAS4YSNN.js";
 import {
   readTextBodies,
   validateTextReadingOptions
-} from "./chunk-FCGMSOF6.js";
+} from "./chunk-P6YTNXRV.js";
 import {
   readXmlCoordinate,
   readXmlInteger
@@ -50,10 +50,10 @@ import {
   attr,
   child,
   loadShared
-} from "./chunk-UDRJKA3P.js";
+} from "./chunk-C23L4HZB.js";
 import {
   SelectionError
-} from "./chunk-SKF6PGA5.js";
+} from "./chunk-I2OKE2NI.js";
 import {
   protectedEquationNodes
 } from "./chunk-PNOXBL2B.js";