poe-code 15.0.5 → 15.0.6

package/packages/safe-fs/dist/core.d.ts

@@ -9,7 +9,8 @@ export * from "./fs/readonly/index.js";
 export * from "./fs/mount/index.js";
 export * from "./fs/overlay/index.js";
 export * from "./fs/quota/index.js";
-export { scopeFileSystem } from "./fs/scoped.js";
+export { scopeFileSystem, retainFileSystemCleanup } from "./fs/scoped.js";
+export type { RetainedFileSystemCleanupView, RetainedFileSystemCleanupOptions } from "./fs/scoped.js";
 export * from "./fs/webdav/index.js";
 export * from "./bridge/index.js";
 export { compareEntries } from "./fs/mount/comparison.js";

package/packages/safe-fs/dist/fs/scoped.d.ts

@@ -1,2 +1,12 @@
-import type { FileSystem } from "../contracts/filesystem.js";
-export declare function scopeFileSystem(filesystem: FileSystem, charge: () => void, signal: AbortSignal): FileSystem;
+import type { FileSystem, FsOptions } from "../contracts/filesystem.js";
+export declare function scopeFileSystem(filesystem: FileSystem, charge: () => void, signal: AbortSignal, cleanupCharge?: () => void): FileSystem;
+export interface RetainedFileSystemCleanupView {
+    readonly lstat: FileSystem["lstat"];
+    readonly realpath: FileSystem["realpath"];
+    readonly rm: (path: string, options?: FsOptions) => Promise<void>;
+    readonly rmdir?: NonNullable<FileSystem["rmdir"]>;
+}
+export interface RetainedFileSystemCleanupOptions {
+    readonly maxOperations?: number;
+}
+export declare function retainFileSystemCleanup(filesystem: FileSystem, cleanupCallback: (view: RetainedFileSystemCleanupView) => void | PromiseLike<void>, options?: RetainedFileSystemCleanupOptions): () => Promise<void>;

package/packages/safe-fs/dist/index.d.ts

@@ -10,7 +10,8 @@ export * from "./fs/readonly/index.js";
 export * from "./fs/mount/index.js";
 export * from "./fs/overlay/index.js";
 export * from "./fs/quota/index.js";
-export { scopeFileSystem } from "./fs/scoped.js";
+export { scopeFileSystem, retainFileSystemCleanup } from "./fs/scoped.js";
+export type { RetainedFileSystemCleanupView, RetainedFileSystemCleanupOptions } from "./fs/scoped.js";
 export * from "./node/index.js";
 export { createFileSystem, readConfigRecord, validateFileSystemConfig } from "./config.js";
 export type { FileSystemConfig, FileSystemAdapterDescriptor, FileSystemAdapterRegistry } from "./config.js";

package/packages/safe-js/dist/browser/chunks/{chunk-GQOAEEHU.js → chunk-3EJ7BQOJ.js}

@@ -4496,8 +4496,8 @@ var operations = /* @__PURE__ */ new Set([
   "writeFile",
   "writeStream"
 ]);
-function scopeFileSystem(filesystem, charge, signal) {
-  const original = originals.get(filesystem) ?? filesystem;
+function scopeFileSystem(filesystem, charge, signal, cleanupCharge = charge) {
+  const original = originals.get(filesystem)?.filesystem ?? filesystem;
   const methods = /* @__PURE__ */ new Map();
   const assertOpen = (options) => {
     signal.throwIfAborted();
@@ -4650,7 +4650,7 @@ function scopeFileSystem(filesystem, charge, signal) {
         }
         if (property === "compareEntry") {
           const peer = args[1];
-          args[1] = originals.get(peer) ?? peer;
+          args[1] = originals.get(peer)?.filesystem ?? peer;
         }
         if (property === "rename" && args[2]?.noReplace) return (async () => {
           const options = args[2];
@@ -4674,13 +4674,96 @@ function scopeFileSystem(filesystem, charge, signal) {
       return scoped;
     }
   });
-  originals.set(view, original);
+  originals.set(view, { filesystem: original, signal, cleanupCharge });
   registerEntryView(view, async (path, options) => {
     assertOpen(options);
     return { filesystem: original, path };
   });
   return view;
 }
+function retainFileSystemCleanup(filesystem, cleanupCallback, options) {
+  const maximum = options?.maxOperations === void 0 ? 256 : options.maxOperations;
+  if (!Number.isSafeInteger(maximum) || maximum < 0 || maximum > 4096) throw new RangeError("cleanup maxOperations must be an integer between 0 and 4096");
+  if (typeof cleanupCallback !== "function") throw new TypeError("cleanup callback must be a function");
+  const scope = originals.get(filesystem);
+  scope?.signal.throwIfAborted();
+  const backing = scope?.filesystem ?? filesystem;
+  const pending = /* @__PURE__ */ new Set();
+  let operations2 = 0;
+  let active = false;
+  let closing;
+  const invoke = (method, path, settings) => {
+    if (!active) {
+      const rejected = Promise.reject(new FsError("EBADF", { syscall: method, path, message: "cleanup callback is not active" }));
+      void rejected.catch(() => {
+      });
+      return rejected;
+    }
+    let result;
+    try {
+      settings?.signal?.throwIfAborted();
+      if (operations2 >= maximum) throw new FsError("EFBIG", { syscall: method, path, message: "cleanup operation limit exceeded" });
+      operations2++;
+      scope?.cleanupCharge();
+      settings?.signal?.throwIfAborted();
+      const operation = backing[method];
+      if (typeof operation !== "function") throw new FsError("ENOTSUP", { syscall: method, path });
+      const parameters = method === "rm" ? { ...settings, recursive: false, force: false } : settings;
+      result = Promise.resolve(Reflect.apply(operation, backing, [path, parameters]));
+    } catch (error) {
+      result = Promise.reject(error);
+      void result.catch(() => {
+      });
+      return result;
+    }
+    const completion = result.then(
+      () => {
+        pending.delete(completion);
+        return { status: "fulfilled", value: void 0 };
+      },
+      (error) => {
+        pending.delete(completion);
+        return { status: "rejected", reason: error };
+      }
+    );
+    pending.add(completion);
+    return result;
+  };
+  const view = Object.freeze(Object.assign(/* @__PURE__ */ Object.create(null), {
+    lstat: invoke.bind(void 0, "lstat"),
+    realpath: invoke.bind(void 0, "realpath"),
+    rm: invoke.bind(void 0, "rm"),
+    ...typeof backing.rmdir === "function" ? { rmdir: invoke.bind(void 0, "rmdir") } : {}
+  }));
+  scope?.signal.throwIfAborted();
+  return () => {
+    if (!closing) {
+      closing = Promise.resolve().then(async () => {
+        active = true;
+        let callbackFailed = false;
+        let callbackFailure;
+        try {
+          const result = cleanupCallback(view);
+          if (result !== void 0) await result;
+        } catch (error) {
+          callbackFailed = true;
+          callbackFailure = error;
+        } finally {
+          active = false;
+        }
+        const outcomes = await Promise.all(pending);
+        if (callbackFailed) throw callbackFailure;
+        const failures = [];
+        for (const outcome of outcomes) if (outcome.status === "rejected") failures.push(outcome.reason);
+        if (failures.length === 1) throw failures[0];
+        if (failures.length > 1) throw new AggregateError(failures, "retained filesystem cleanup failed");
+      });
+      void closing.catch(() => {
+      });
+    }
+    return closing;
+  };
+}
 
 // packages/safe-fs/src/contracts/abort.ts
 function composeAbortSignals(signals) {
@@ -6951,10 +7034,11 @@ export {
   FileSystemQuotaError,
   withFileSystemQuota,
   scopeFileSystem,
+  retainFileSystemCleanup,
   XmlLimitError,
   parseXmlSteps,
   parseXml,
   WebDavFileSystem,
   createFsBridge
 };
-//# sourceMappingURL=chunk-GQOAEEHU.js.map
+//# sourceMappingURL=chunk-3EJ7BQOJ.js.map