@poe-platform/safe-bash 0.1.610 → 0.1.612

package/dist/safe-bash/core.browser.js

@@ -26896,7 +26896,7 @@ async function* decodeZipEntry(entry, limits, signal) {
     await reader.close();
   }
 }
-async function makeZipEntry(name2, bytes3, attributes, limits, signal) {
+async function makeZipEntry(name2, bytes3, attributes, limits, signal, level = 6) {
   const chunkSize2 = admit(limits, signal);
   const entry = { name: name2, data: bytes3, size: bytes3.length, method: 0, crc32: 0, ...attributes, modified: new Date(attributes.modified.getTime()) };
   entryBounds(entry, limits);
@@ -26908,10 +26908,10 @@ async function makeZipEntry(name2, bytes3, attributes, limits, signal) {
     yield bytes3;
   })(), signal);
   try {
-    if (bytes3.length && !entry.directory && !entry.symlink) {
+    if (level !== 0 && bytes3.length && !entry.directory && !entry.symlink) {
       const chunks = [];
       let length = 0;
-      for await (const chunk of codec(reader, { mode: "deflate-raw", chunkSize: chunkSize2 }, signal)) {
+      for await (const chunk of codec(reader, { mode: "deflate-raw", chunkSize: chunkSize2, level }, signal)) {
         length += chunk.length;
         if (length >= bytes3.length) break;
         chunks.push(new Uint8Array(chunk));
@@ -27194,6 +27194,188 @@ async function publishZip(scope, prepared) {
   if (failure) throw failure.reason;
 }
 
+// packages/safe-bash/src/commands/archive/unzip/arguments.ts
+init_platform();
+function parseArguments(context2, limits) {
+  const { args } = context2;
+  let bytes3 = 0;
+  for (const argument2 of args) {
+    bytes3 += import_buffer.Buffer.byteLength(argument2) + 1;
+    if (bytes3 > limits.maxArgumentBytes) fail("argument byte limit exceeded");
+    if (argument2.includes("\0")) fail("NUL in argument");
+  }
+  if (context2.argumentValues) {
+    const argumentsValue = getCommandArguments(context2);
+    let rawBytes = 0;
+    for (const value2 of argumentsValue.values) {
+      const size = shellValueByteLength(value2) + 1;
+      if (size > limits.maxArgumentBytes - rawBytes) fail("argument byte limit exceeded");
+      rawBytes += size;
+    }
+    for (const value2 of argumentsValue.values) text2(shellValueBytes(value2));
+  }
+  let list = false;
+  let pipe = false;
+  let overwrite = false;
+  let destination2;
+  let archive;
+  let ended = false;
+  const patterns2 = [];
+  for (let index = 0; index < args.length; index++) {
+    const argument2 = args[index];
+    if (!ended && argument2 === "--") {
+      ended = true;
+      continue;
+    }
+    if (!ended && argument2.startsWith("-") && argument2 !== "-") {
+      for (let offset = 1; offset < argument2.length; offset++) {
+        const flag = argument2[offset];
+        if (flag === "l") list = true;
+        else if (flag === "p") pipe = true;
+        else if (flag === "o") overwrite = true;
+        else if (flag === "d") {
+          if (destination2 !== void 0) fail("-d may only be specified once");
+          destination2 = argument2.slice(offset + 1) || args[++index];
+          if (!destination2) fail("must specify directory to which to extract with -d option");
+          checkPath(destination2, limits);
+          break;
+        } else fail(`unsupported option: -${flag}`);
+      }
+    } else if (archive === void 0) archive = argument2;
+    else patterns2.push(argument2);
+  }
+  if (archive === void 0) fail("usage: unzip [-l] [-p] [-o] [-d DIR] ARCHIVE [FILES...]");
+  checkPath(archive, limits);
+  return { list: list && !pipe, pipe, overwrite, destination: destination2, archive, patterns: patterns2 };
+}
+function tokenize2(pattern) {
+  const characters = Array.from(pattern);
+  const tokens2 = [];
+  for (let index = 0; index < characters.length; index++) {
+    const character = characters[index];
+    if (character === "*") {
+      if (tokens2.at(-1)?.kind !== "star") tokens2.push({ kind: "star" });
+    } else if (character === "?") tokens2.push({ kind: "any" });
+    else if (character === "\\") {
+      const escaped3 = characters[++index];
+      tokens2.push(escaped3 === void 0 ? { kind: "never" } : { kind: "literal", value: escaped3 });
+    } else if (character === "[") {
+      const negative = characters[index + 1] === "!" || characters[index + 1] === "^";
+      if (negative) index++;
+      const ranges = [];
+      let closed = false;
+      while (++index < characters.length) {
+        let first = characters[index];
+        if (first === "]") {
+          closed = true;
+          break;
+        }
+        if (first === "\\") first = characters[++index] ?? "";
+        let last = first;
+        if (characters[index + 1] === "-" && characters[index + 2] && characters[index + 2] !== "]") {
+          index += 2;
+          last = characters[index];
+          if (last === "\\") last = characters[++index] ?? "";
+        }
+        ranges.push([first.codePointAt(0) ?? -1, last.codePointAt(0) ?? -1]);
+      }
+      tokens2.push(closed ? { kind: "class", ranges, negative } : { kind: "never" });
+    } else tokens2.push({ kind: "literal", value: character });
+  }
+  return tokens2;
+}
+var Selection = class {
+  constructor(patterns2, limits, signal) {
+    this.limits = limits;
+    this.signal = signal;
+    this.patterns = patterns2.map(tokenize2);
+  }
+  limits;
+  signal;
+  work = 0;
+  patterns;
+  matched = /* @__PURE__ */ new Set();
+  step() {
+    if (++this.work > this.limits.maxPatternSteps) fail("pattern work limit exceeded");
+  }
+  async matches(name2, firstMatchOnly = false) {
+    if (!this.patterns.length) return true;
+    const characters = Array.from(name2);
+    let selected = false;
+    for (let pattern = 0; pattern < this.patterns.length; pattern++) {
+      this.step();
+      let states = new Uint8Array(characters.length + 1);
+      states[0] = 1;
+      for (const token of this.patterns[pattern]) {
+        const next = new Uint8Array(states.length);
+        for (let index = 0; index < states.length; index++) {
+          this.step();
+          if (token.kind === "star") next[index] = states[index] || (index > 0 ? next[index - 1] : 0);
+          else if (states[index] && index < characters.length) {
+            const character = characters[index];
+            let match = token.kind === "any" || token.kind === "literal" && token.value === character;
+            if (token.kind === "class") {
+              let inRange = false;
+              for (const [first, last] of token.ranges) {
+                this.step();
+                if (character.codePointAt(0) >= first && character.codePointAt(0) <= last) inRange = true;
+              }
+              match = inRange !== token.negative;
+            }
+            if (match) next[index + 1] = 1;
+          }
+          if (this.work % 4096 === 0) await yieldTurn(this.signal);
+        }
+        states = next;
+      }
+      if (states[characters.length]) {
+        this.matched.add(pattern);
+        if (firstMatchOnly) return true;
+        selected = true;
+      }
+    }
+    return selected;
+  }
+};
+var Answers = class {
+  constructor(source2, limits, signal) {
+    this.limits = limits;
+    this.signal = signal;
+    this.iterator = readBytes(source2, signal)[Symbol.asyncIterator]();
+  }
+  limits;
+  signal;
+  iterator;
+  chunk = new Uint8Array();
+  offset = 0;
+  bytes = 0;
+  pulls = 0;
+  async read(maximum = 9) {
+    const answer = [];
+    while (answer.length < maximum) {
+      this.signal.throwIfAborted();
+      if (this.offset === this.chunk.length) {
+        if (++this.pulls > this.limits.maxPatternSteps) fail("overwrite input work limit exceeded");
+        if (this.pulls % 64 === 0) await yieldTurn(this.signal);
+        const next = await this.iterator.next();
+        if (next.done) break;
+        if (next.value.length > this.limits.maxFilesFromBytes - this.bytes) fail("overwrite input byte limit exceeded");
+        this.bytes += next.value.length;
+        this.chunk = Uint8Array.from(next.value);
+        this.offset = 0;
+        if (!this.chunk.length) continue;
+      }
+      const byte = this.chunk[this.offset++];
+      answer.push(byte);
+      if (byte === 10) break;
+    }
+    return answer.length ? import_buffer.Buffer.from(answer).toString("utf8") : void 0;
+  }
+  async close() {
+    await this.iterator.return?.();
+  }
+};
+
 // packages/safe-bash/src/commands/archive/zip.ts
 var ZipFailure = class extends Error {
   constructor(status2, label, detail) {
@@ -27204,7 +27386,8 @@ var ZipFailure = class extends Error {
   status;
   label;
 };
-function parse12(context2, limits) {
+async function parse12(scope, limits) {
+  const context2 = scope.context;
   if (context2.args.length > limits.maxArgumentBytes) fail("argument count limit exceeded");
   let bytes3 = 0;
   for (const argument2 of context2.args) {
@@ -27226,20 +27409,49 @@ function parse12(context2, limits) {
   let recursive = false;
   let quiet = false;
   let junkPaths = false;
+  let level = 6;
+  let stdinNames = false;
   let literal = false;
   let firstOperand = -1;
   const operands = [];
-  for (const [index, argument2] of context2.args.entries()) {
+  const includes = [];
+  const excludes = [];
+  for (let index = 0; index < context2.args.length; index++) {
+    const argument2 = context2.args[index];
     checkPath(argument2, limits);
     if (!literal && argument2 === "--") {
       if (archive === void 0) throw new ZipFailure(16, "Invalid command arguments", "can't use -- before archive name");
       literal = true;
     } else if (!literal && argument2.startsWith("-") && argument2 !== "-") {
-      for (const flag of argument2.slice(1)) {
+      for (let offset = 1; offset < argument2.length; offset++) {
+        const flag = argument2[offset];
         if (flag === "r") recursive = true;
         else if (flag === "q") quiet = true;
         else if (flag === "j") junkPaths = true;
-        else throw new ZipFailure(16, "Invalid command arguments", `unsupported option: ${argument2}`);
+        else if (flag === "@") stdinNames = true;
+        else if (flag !== void 0 && flag >= "0" && flag <= "9") level = Number(flag);
+        else if (flag === "i" || flag === "x") {
+          const patterns2 = flag === "i" ? includes : excludes;
+          const before = patterns2.length;
+          const append = (pattern) => {
+            checkPath(pattern, limits);
+            if (includes.length + excludes.length >= limits.maxMembers) fail("pattern count limit exceeded");
+            patterns2.push(pattern);
+          };
+          if (offset + 1 < argument2.length) append(argument2.slice(offset + 1));
+          while (index + 1 < context2.args.length) {
+            const next = context2.args[index + 1];
+            if (next === "@") {
+              index++;
+              break;
+            }
+            if (next.startsWith("-") && next !== "-") break;
+            append(next);
+            index++;
+          }
+          if (patterns2.length === before) throw new ZipFailure(16, "Invalid command arguments", `option '${flag}' requires a value`);
+          break;
+        } else throw new ZipFailure(16, "Invalid command arguments", `unsupported option: ${argument2}`);
       }
     } else if (archive === void 0) archive = argument2;
     else {
@@ -27248,11 +27460,32 @@ function parse12(context2, limits) {
       operands.push(argument2);
     }
   }
-  if (archive === void 0) throw new ZipFailure(16, "Invalid command arguments", "expected zip [-r] [-q] [-j] ARCHIVE FILES...");
+  if (archive === void 0) throw new ZipFailure(16, "Invalid command arguments", "expected zip [-r] [-q] [-j] [-@] [-0..-9] ARCHIVE FILES... [-i PATTERNS...] [-x PATTERNS...]");
   if (archive === "-" || operands.includes("-")) throw new ZipFailure(16, "Invalid command arguments", "standard input/output archives are unsupported");
   if (!archive.slice(archive.lastIndexOf("/") + 1).includes(".")) archive += ".zip";
   checkPath(archive, limits);
-  return { archive, recursive, quiet, junkPaths, operands, firstOperand };
+  const names = [];
+  if (stdinNames) {
+    const input3 = await collectBytes(scope.source(context2.stdin), { maxBytes: limits.maxFilesFromBytes, signal: context2.signal });
+    let start = 0;
+    let lines3 = 0;
+    for (let end = 0; end <= input3.length; end++) {
+      if (end !== input3.length && input3[end] !== 10) continue;
+      if (++lines3 > limits.maxPatternSteps) fail("stdin filename work limit exceeded");
+      if (lines3 % 128 === 0) await yieldTurn(context2.signal);
+      let last = end;
+      while (last > start && input3[last - 1] === 13) last--;
+      if (last > start) {
+        if (names.length + operands.length >= limits.maxMembers) fail("operand limit exceeded");
+        if (last - start > limits.maxPathBytes) fail("path byte limit exceeded");
+        const name2 = text2(input3.subarray(start, last));
+        checkPath(name2, limits);
+        names.push(name2);
+      }
+      start = end + 1;
+    }
+  }
+  return { archive, recursive, quiet, junkPaths, includes, excludes, level, operands: [...names, ...operands], firstOperand };
 }
 function memberName(path, limits) {
   if (path.startsWith("//") && !path.startsWith("///")) fail("UNC source paths are unsupported");
@@ -27289,6 +27522,7 @@ async function prepare(scope, parsed, budget) {
   }
   const old = new Map(archive.entries.map((entry) => [entry.name, entry]));
   const selected = /* @__PURE__ */ new Map();
+  const selection = new Selection([...parsed.includes, ...parsed.excludes], limits, context2.signal);
   const ancestors = [];
   let visits = 0;
   let work = 0;
@@ -27322,9 +27556,18 @@ async function prepare(scope, parsed, budget) {
     }
     if (existing2 && !hasIdentity(stat)) fail("cannot exclude archive aliases when source backing identity is unknown");
     const directory2 = stat.type === "directory";
-    if (parsed.junkPaths) name2 = directory2 ? "" : name2.slice(name2.lastIndexOf("/") + 1);
     if (directory2 && name2 && !name2.endsWith("/")) name2 += "/";
-    if (name2) {
+    selection.matched.clear();
+    await selection.matches(name2);
+    let included = parsed.includes.length === 0;
+    let excluded = false;
+    for (const pattern of selection.matched) {
+      if (pattern < parsed.includes.length) included = true;
+      else excluded = true;
+    }
+    const sourceName = name2;
+    if (parsed.junkPaths) name2 = directory2 ? "" : name2.slice(name2.lastIndexOf("/") + 1);
+    if (name2 && included && !excluded) {
       checkPath(name2, limits);
       const previous = selected.get(name2);
       if (previous && previous.source !== source2) {
@@ -27341,7 +27584,7 @@ async function prepare(scope, parsed, budget) {
         const current = await scope.operation(() => context2.fs.stat(path, { signal: context2.signal }));
         const currentPath = await scope.operation(() => context2.fs.realpath(path, { signal: context2.signal }));
         if (currentPath !== canonical || !unchanged4(stat, current)) fail(`source changed while reading: ${source2}`);
-        let entry = await makeZipEntry(name2, bytes4, { modified: new Date(stat.mtimeMs), mode: stat.mode, directory: directory2, symlink: false }, limits, context2.signal);
+        let entry = await makeZipEntry(name2, bytes4, { modified: new Date(stat.mtimeMs), mode: stat.mode, directory: directory2, symlink: false }, limits, context2.signal, parsed.level);
         if ([".z", ".zip", ".zoo", ".arc", ".lzh", ".arj"].some((suffix2) => name2.toLowerCase().endsWith(suffix2))) entry = { ...entry, method: 0, data: bytes4 };
         const prior = old.get(name2);
         if (prior?.comment) entry = { ...entry, comment: prior.comment };
@@ -27359,7 +27602,7 @@ async function prepare(scope, parsed, budget) {
         for (const child of children) {
           if (!child.name || child.name === "." || child.name === ".." || child.name.includes("/") || child.name.includes("\0")) fail("invalid filesystem directory entry");
           const prefix3 = source2 === "." ? "" : source2.endsWith("/") ? source2 : `${source2}/`;
-          await visit(`${prefix3}${child.name}`, `${name2}${child.name}`, depth + 1);
+          await visit(`${prefix3}${child.name}`, `${sourceName}${child.name}`, depth + 1);
         }
       } finally {
         ancestors.pop();
@@ -27367,7 +27610,7 @@ async function prepare(scope, parsed, budget) {
     }
   };
   for (const operand of parsed.operands) await visit(operand, memberName(operand, limits), 0);
-  if (!selected.size) {
+  if (!selected.size && !parsed.includes.length) {
     const detail = parsed.recursive && parsed.firstOperand >= 0 ? `try: zip ${context2.args.slice(0, parsed.firstOperand).join(" ")} . -i ${context2.args.slice(parsed.firstOperand).join(" ")}` : parsed.archive;
     throw new ZipFailure(12, "Nothing to do!", detail);
   }
@@ -27400,6 +27643,7 @@ async function prepare(scope, parsed, budget) {
     entries2.push(entry);
     append(entry, false);
   }
+  if (!entries2.length && !parsed.quiet) await budget.output("	zip warning: zip file empty\n");
   const bytes3 = await writeZipArchive({ entries: entries2, comment: archive.comment }, limits, context2.signal);
   return { output: output2, parentName, parent, parentStat, existing: existing2, bytes: bytes3, progress };
 }
@@ -27411,7 +27655,7 @@ function createZipCommand(options2 = {}) {
     const context2 = scope.context;
     const budget = new Budget14(context2, limits);
     try {
-      const parsed = parse12(context2, limits);
+      const parsed = await parse12(scope, limits);
       const prepared = await prepare(scope, parsed, budget);
       await writeFileOutput(context2, prepared.bytes, () => scope.operation(() => publishZip(scope, prepared)));
       for (const message3 of prepared.progress) await budget.output(message3);
@@ -27442,188 +27686,6 @@ zip error: ${error.label} (${error.message})
 // packages/safe-bash/src/commands/archive/unzip.ts
 init_platform();
 
-// packages/safe-bash/src/commands/archive/unzip/arguments.ts
-init_platform();
-function parseArguments(context2, limits) {
-  const { args } = context2;
-  let bytes3 = 0;
-  for (const argument2 of args) {
-    bytes3 += import_buffer.Buffer.byteLength(argument2) + 1;
-    if (bytes3 > limits.maxArgumentBytes) fail("argument byte limit exceeded");
-    if (argument2.includes("\0")) fail("NUL in argument");
-  }
-  if (context2.argumentValues) {
-    const argumentsValue = getCommandArguments(context2);
-    let rawBytes = 0;
-    for (const value2 of argumentsValue.values) {
-      const size = shellValueByteLength(value2) + 1;
-      if (size > limits.maxArgumentBytes - rawBytes) fail("argument byte limit exceeded");
-      rawBytes += size;
-    }
-    for (const value2 of argumentsValue.values) text2(shellValueBytes(value2));
-  }
-  let list = false;
-  let pipe = false;
-  let overwrite = false;
-  let destination2;
-  let archive;
-  let ended = false;
-  const patterns2 = [];
-  for (let index = 0; index < args.length; index++) {
-    const argument2 = args[index];
-    if (!ended && argument2 === "--") {
-      ended = true;
-      continue;
-    }
-    if (!ended && argument2.startsWith("-") && argument2 !== "-") {
-      for (let offset = 1; offset < argument2.length; offset++) {
-        const flag = argument2[offset];
-        if (flag === "l") list = true;
-        else if (flag === "p") pipe = true;
-        else if (flag === "o") overwrite = true;
-        else if (flag === "d") {
-          if (destination2 !== void 0) fail("-d may only be specified once");
-          destination2 = argument2.slice(offset + 1) || args[++index];
-          if (!destination2) fail("must specify directory to which to extract with -d option");
-          checkPath(destination2, limits);
-          break;
-        } else fail(`unsupported option: -${flag}`);
-      }
-    } else if (archive === void 0) archive = argument2;
-    else patterns2.push(argument2);
-  }
-  if (archive === void 0) fail("usage: unzip [-l] [-p] [-o] [-d DIR] ARCHIVE [FILES...]");
-  checkPath(archive, limits);
-  return { list: list && !pipe, pipe, overwrite, destination: destination2, archive, patterns: patterns2 };
-}
-function tokenize2(pattern) {
-  const characters = Array.from(pattern);
-  const tokens2 = [];
-  for (let index = 0; index < characters.length; index++) {
-    const character = characters[index];
-    if (character === "*") {
-      if (tokens2.at(-1)?.kind !== "star") tokens2.push({ kind: "star" });
-    } else if (character === "?") tokens2.push({ kind: "any" });
-    else if (character === "\\") {
-      const escaped3 = characters[++index];
-      tokens2.push(escaped3 === void 0 ? { kind: "never" } : { kind: "literal", value: escaped3 });
-    } else if (character === "[") {
-      const negative = characters[index + 1] === "!" || characters[index + 1] === "^";
-      if (negative) index++;
-      const ranges = [];
-      let closed = false;
-      while (++index < characters.length) {
-        let first = characters[index];
-        if (first === "]") {
-          closed = true;
-          break;
-        }
-        if (first === "\\") first = characters[++index] ?? "";
-        let last = first;
-        if (characters[index + 1] === "-" && characters[index + 2] && characters[index + 2] !== "]") {
-          index += 2;
-          last = characters[index];
-          if (last === "\\") last = characters[++index] ?? "";
-        }
-        ranges.push([first.codePointAt(0) ?? -1, last.codePointAt(0) ?? -1]);
-      }
-      tokens2.push(closed ? { kind: "class", ranges, negative } : { kind: "never" });
-    } else tokens2.push({ kind: "literal", value: character });
-  }
-  return tokens2;
-}
-var Selection = class {
-  constructor(patterns2, limits, signal) {
-    this.limits = limits;
-    this.signal = signal;
-    this.patterns = patterns2.map(tokenize2);
-  }
-  limits;
-  signal;
-  work = 0;
-  patterns;
-  matched = /* @__PURE__ */ new Set();
-  step() {
-    if (++this.work > this.limits.maxPatternSteps) fail("pattern work limit exceeded");
-  }
-  async matches(name2, firstMatchOnly = false) {
-    if (!this.patterns.length) return true;
-    const characters = Array.from(name2);
-    let selected = false;
-    for (let pattern = 0; pattern < this.patterns.length; pattern++) {
-      this.step();
-      let states = new Uint8Array(characters.length + 1);
-      states[0] = 1;
-      for (const token of this.patterns[pattern]) {
-        const next = new Uint8Array(states.length);
-        for (let index = 0; index < states.length; index++) {
-          this.step();
-          if (token.kind === "star") next[index] = states[index] || (index > 0 ? next[index - 1] : 0);
-          else if (states[index] && index < characters.length) {
-            const character = characters[index];
-            let match = token.kind === "any" || token.kind === "literal" && token.value === character;
-            if (token.kind === "class") {
-              let inRange = false;
-              for (const [first, last] of token.ranges) {
-                this.step();
-                if (character.codePointAt(0) >= first && character.codePointAt(0) <= last) inRange = true;
-              }
-              match = inRange !== token.negative;
-            }
-            if (match) next[index + 1] = 1;
-          }
-          if (this.work % 4096 === 0) await yieldTurn(this.signal);
-        }
-        states = next;
-      }
-      if (states[characters.length]) {
-        this.matched.add(pattern);
-        if (firstMatchOnly) return true;
-        selected = true;
-      }
-    }
-    return selected;
-  }
-};
-var Answers = class {
-  constructor(source2, limits, signal) {
-    this.limits = limits;
-    this.signal = signal;
-    this.iterator = readBytes(source2, signal)[Symbol.asyncIterator]();
-  }
-  limits;
-  signal;
-  iterator;
-  chunk = new Uint8Array();
-  offset = 0;
-  bytes = 0;
-  pulls = 0;
-  async read(maximum = 9) {
-    const answer = [];
-    while (answer.length < maximum) {
-      this.signal.throwIfAborted();
-      if (this.offset === this.chunk.length) {
-        if (++this.pulls > this.limits.maxPatternSteps) fail("overwrite input work limit exceeded");
-        if (this.pulls % 64 === 0) await yieldTurn(this.signal);
-        const next = await this.iterator.next();
-        if (next.done) break;
-        if (next.value.length > this.limits.maxFilesFromBytes - this.bytes) fail("overwrite input byte limit exceeded");
-        this.bytes += next.value.length;
-        this.chunk = Uint8Array.from(next.value);
-        this.offset = 0;
-        if (!this.chunk.length) continue;
-      }
-      const byte = this.chunk[this.offset++];
-      answer.push(byte);
-      if (byte === 10) break;
-    }
-    return answer.length ? import_buffer.Buffer.from(answer).toString("utf8") : void 0;
-  }
-  async close() {
-    await this.iterator.return?.();
-  }
-};
-
 // packages/safe-bash/src/commands/archive/unzip/safety.ts
 init_platform();
 import { retainFileSystemCleanup as retainFileSystemCleanup3 } from "@poe-platform/safe-fs/core";