poe-code 14.0.21 → 14.0.23

package/packages/safe-js/dist/browser/safe-fs-core.js

@@ -1,5 +1,6 @@
 import {
   ACCESS_MODES,
+  FileSystemQuotaError,
   FsError,
   MemoryFileSystem,
   MountFileSystem,
@@ -29,10 +30,12 @@ import {
   resolvePath,
   toByteSource,
   toFsError,
-  validatePath
-} from "./chunks/chunk-QGN6DKT5.js";
+  validatePath,
+  withFileSystemQuota
+} from "./chunks/chunk-EMJUKJ6C.js";
 export {
   ACCESS_MODES,
+  FileSystemQuotaError,
   FsError,
   MemoryFileSystem,
   MountFileSystem,
@@ -62,6 +65,7 @@ export {
   resolvePath,
   toByteSource,
   toFsError,
-  validatePath
+  validatePath,
+  withFileSystemQuota
 };
 //# sourceMappingURL=safe-fs-core.js.map

package/packages/safe-js/dist/browser/safe-fs.js

@@ -1,5 +1,6 @@
 import {
   ACCESS_MODES,
+  FileSystemQuotaError,
   FsError,
   MemoryFileSystem,
   MountFileSystem,
@@ -29,10 +30,12 @@ import {
   resolvePath,
   toByteSource,
   toFsError,
-  validatePath
-} from "./chunks/chunk-QGN6DKT5.js";
+  validatePath,
+  withFileSystemQuota
+} from "./chunks/chunk-EMJUKJ6C.js";
 export {
   ACCESS_MODES,
+  FileSystemQuotaError,
   FsError,
   MemoryFileSystem,
   MountFileSystem,
@@ -62,6 +65,7 @@ export {
   resolvePath,
   toByteSource,
   toFsError,
-  validatePath
+  validatePath,
+  withFileSystemQuota
 };
 //# sourceMappingURL=safe-fs.js.map

package/packages/safe-js/dist/chunks/{chunk-7M2SJPSZ.js → chunk-AFVEPD3R.js}

@@ -16,7 +16,7 @@ import {
   toByteSource,
   toFsError,
   validatePath
-} from "./chunk-2QRYPKQQ.js";
+} from "./chunk-WMZQYBLB.js";
 
 // packages/safe-fs/src/contracts/path.ts
 import { posix } from "node:path";
@@ -2610,4 +2610,4 @@ export {
   createFileSystem,
   createNodeFileSystemAdapterRegistry
 };
-//# sourceMappingURL=chunk-7M2SJPSZ.js.map
+//# sourceMappingURL=chunk-AFVEPD3R.js.map

package/packages/safe-js/dist/chunks/{chunk-5XRQ3GNN.js → chunk-WGUFH7HF.js}

@@ -34,11 +34,11 @@ import {
   createNodeFsBridge,
   readConfigRecord,
   validateFileSystemConfig
-} from "./chunk-7M2SJPSZ.js";
+} from "./chunk-AFVEPD3R.js";
 import {
   FsError,
   isPathWithin
-} from "./chunk-2QRYPKQQ.js";
+} from "./chunk-WMZQYBLB.js";
 
 // packages/safe-js/src/migrate.ts
 import { createHash } from "node:crypto";
@@ -8245,4 +8245,4 @@ export {
   parseMcpConfig,
   makeMcpModule
 };
-//# sourceMappingURL=chunk-5XRQ3GNN.js.map
+//# sourceMappingURL=chunk-WGUFH7HF.js.map

package/packages/safe-js/dist/chunks/{chunk-2QRYPKQQ.js → chunk-WMZQYBLB.js}

@@ -2329,6 +2329,7 @@ var ReadOnlyFileSystem = class {
     const streamingRead = typeof filesystem.readStream === "function" ? filesystem.capabilities.streamingRead : false;
     this.#capabilities = Object.freeze({
       readOnly: true,
+      append: false,
       symlinks: filesystem.capabilities.symlinks === true && typeof filesystem.readlink === "function",
       hardlinks: false,
       permissions: false,
@@ -2507,11 +2508,13 @@ var MountFileSystem = class _MountFileSystem {
     const streaming = (capability, method) => all(capability, [method]) ? true : mounts.some(({ backend }) => backend.capabilities[capability] !== false && typeof backend[method] === "function") ? void 0 : false;
     const streamingRead = streaming("streamingRead", "readStream");
     const streamingWrite = streaming("streamingWrite", "writeStream");
+    const append = all("append") ? true : mounts.every(({ backend }) => backend.capabilities.append === false) ? false : void 0;
     this.capabilities = Object.freeze({
       get snapshotRmdir() {
         return mounts.some(({ backend }) => backend.capabilities.snapshotRmdir === true);
       },
       readOnly: all("readOnly"),
+      ...append === void 0 ? {} : { append },
       symlinks: all("symlinks", ["readlink", "symlink"]),
       hardlinks: all("hardlinks", ["link"]),
       permissions: all("permissions", ["chmod"]),
@@ -2996,8 +2999,10 @@ var OverlayFileSystem = class {
     const readable = [this.#upper, this.#lower].map((backend) => typeof backend.readStream === "function" ? backend.capabilities.streamingRead : false);
     const streamingRead = readable.every((capability) => capability === true) ? true : readable.every((capability) => capability === false) ? false : void 0;
     const streamingWrite = writable && this.#upper.capabilities.streamingWrite === true && this.#upper.capabilities.streamingRead === true && typeof this.#upper.writeStream === "function" && typeof this.#upper.readStream === "function" ? readable.every((capability) => capability === true) ? true : void 0 : false;
+    const append = !writable || this.#upper.capabilities.append === false ? false : this.#upper.capabilities.append === true ? true : void 0;
     this.capabilities = Object.freeze({
       readOnly: !writable,
+      ...append === void 0 ? {} : { append },
       atomicRename: false,
       hardlinks: false,
       symlinks: writable && this.#upper.capabilities.symlinks === true && typeof this.#upper.symlink === "function" && typeof this.#upper.readlink === "function" && (this.#lower.capabilities.symlinks !== true || typeof this.#lower.readlink === "function"),
@@ -3688,6 +3693,109 @@ function createOverlayFileSystem(options) {
   return new OverlayFileSystem(options);
 }
 
+// packages/safe-fs/src/fs/quota/index.ts
+var FileSystemQuotaError = class extends Error {
+  constructor(maxBytes) {
+    super(`Filesystem quota exceeded (${maxBytes} bytes)`);
+    this.maxBytes = maxBytes;
+    this.name = "FileSystemQuotaError";
+  }
+  maxBytes;
+};
+async function usedBytes(fs, options) {
+  let total = 0;
+  const pending = ["/"];
+  while (pending.length) {
+    const directory = pending.pop();
+    for (const entry of await fs.readdir(directory, options)) {
+      const path = `${directory === "/" ? "" : directory}/${entry.name}`;
+      if (entry.type === "directory") pending.push(path);
+      else total += (await fs.lstat(path, options)).size;
+    }
+  }
+  return total;
+}
+async function existingBytes(fs, path, options) {
+  try {
+    const stat = await fs.lstat(path, options);
+    return stat.type === "directory" ? 0 : stat.size;
+  } catch (error) {
+    if (error instanceof Error && "code" in error && error.code === "ENOENT") return 0;
+    throw error;
+  }
+}
+function withFileSystemQuota(fs, options) {
+  if (!Number.isSafeInteger(options.maxBytes) || options.maxBytes < 0) throw new RangeError("maxBytes must be a nonnegative safe integer");
+  let queue = Promise.resolve();
+  const mutate = (operation) => {
+    const result = queue.then(operation);
+    queue = result.catch(() => void 0);
+    return result;
+  };
+  const assertDelta = async (path, nextBytes, fsOptions) => {
+    const current = await existingBytes(fs, path, fsOptions);
+    if (await usedBytes(fs, fsOptions) - current + nextBytes > options.maxBytes) throw new FileSystemQuotaError(options.maxBytes);
+  };
+  const mutations = {
+    writeFile(path, data, writeOptions) {
+      return mutate(async () => {
+        const append = writeOptions?.flag === "a" || writeOptions?.flag === "ax";
+        const current = append ? await existingBytes(fs, path, writeOptions) : 0;
+        await assertDelta(path, current + data.length, writeOptions);
+        await fs.writeFile(path, data, writeOptions);
+      });
+    },
+    appendFile(path, data, appendOptions) {
+      return mutate(async () => {
+        await assertDelta(path, await existingBytes(fs, path, appendOptions) + data.length, appendOptions);
+        await fs.appendFile(path, data, appendOptions);
+      });
+    },
+    copyFile(source, destination, copyOptions) {
+      return mutate(async () => {
+        await assertDelta(destination, (await fs.stat(source, copyOptions)).size, copyOptions);
+        await fs.copyFile(source, destination, copyOptions);
+      });
+    },
+    truncate(path, length = 0, truncateOptions) {
+      return mutate(async () => {
+        await assertDelta(path, length, truncateOptions);
+        await fs.truncate(path, length, truncateOptions);
+      });
+    },
+    link(source, destination, linkOptions) {
+      return mutate(async () => {
+        await assertDelta(destination, (await fs.stat(source, linkOptions)).size, linkOptions);
+        await fs.link(source, destination, linkOptions);
+      });
+    },
+    symlink(target, path, linkOptions) {
+      return mutate(async () => {
+        await assertDelta(path, new TextEncoder().encode(target).length, linkOptions);
+        await fs.symlink(target, path, linkOptions);
+      });
+    },
+    writeStream(path, source, writeOptions) {
+      return mutate(async () => {
+        const append = writeOptions?.flag === "a" || writeOptions?.flag === "ax";
+        if (!append) await fs.writeFile(path, new Uint8Array(), writeOptions);
+        for await (const chunk of source) {
+          await assertDelta(path, await existingBytes(fs, path, writeOptions) + chunk.length, writeOptions);
+          await fs.appendFile(path, chunk, writeOptions);
+        }
+      });
+    }
+  };
+  return new Proxy(fs, {
+    get(target, property) {
+      const replacement = Reflect.get(mutations, property);
+      if (typeof replacement === "function") return replacement;
+      const original = Reflect.get(target, property);
+      return typeof original === "function" ? original.bind(target) : original;
+    }
+  });
+}
+
 // packages/safe-fs/src/bridge/stats.ts
 function predicates(type) {
   return {
@@ -4310,6 +4418,8 @@ export {
   createMountFileSystem,
   OverlayFileSystem,
   createOverlayFileSystem,
+  FileSystemQuotaError,
+  withFileSystemQuota,
   FileSystemBridge
 };
-//# sourceMappingURL=chunk-2QRYPKQQ.js.map
+//# sourceMappingURL=chunk-WMZQYBLB.js.map