poe-code 14.0.94 → 14.0.96

package/packages/safe-js/dist/browser/chunks/{chunk-I3HSJDAA.js → chunk-QK4IEGRO.js}

@@ -775,6 +775,7 @@ var MemoryFileSystem = class _MemoryFileSystem {
       removeDirectory: true,
       recursiveRemove: true,
       rename: true,
+      atomicRenameNoReplace: true,
       copy: true,
       exclusiveCopy: true,
       readlink: true,
@@ -1199,6 +1200,7 @@ var MemoryFileSystem = class _MemoryFileSystem {
       if (this.terminalDot(source) || this.terminalDot(destination)) this.fail("EINVAL", "rename", source, destination);
       if (node === this.root || target.node === this.root) this.fail("EBUSY", "rename", source, destination);
       if (destination.endsWith("/") && node.type !== "directory") this.fail("ENOTDIR", "rename", source, destination);
+      if (options.noReplace && target.node) this.fail("EEXIST", "rename", source, destination);
       if (target.node === node) return;
       if (node.type === "directory" && target.path.startsWith(`${origin.path}/`)) this.fail("EINVAL", "rename", source, destination);
       this.permission(origin.parent, 3, "rename", source);
@@ -1489,6 +1491,574 @@ function createMemoryFileSystem(options = {}) {
   return new MemoryFileSystem(normalizeMemoryFileSystemLimits(options));
 }
 
+// packages/safe-fs/src/fs/devices/path.ts
+var nullPath = "/dev/null";
+var deviceDirectory = "/dev";
+function lexicalDevicePath(path) {
+  validatePath(path);
+  const parts = [];
+  for (const component of path.split("/")) {
+    if (`/${parts.join("/")}` === nullPath) throw new FsError("ENOTDIR", { path });
+    if (component === "..") parts.pop();
+    else if (component && component !== ".") parts.push(component);
+  }
+  return `/${parts.join("/")}`;
+}
+async function resolveDevicePath(filesystem, path, options, followFinal = true) {
+  options.signal?.throwIfAborted();
+  const lexical = lexicalDevicePath(path);
+  const aliases = typeof filesystem.lstat === "function";
+  if (!aliases && lexical !== nullPath && lexical !== deviceDirectory && lexical !== "/") return lexical;
+  const pending = path.split("/");
+  const parts = [];
+  let links = 0;
+  let expanded = path.length;
+  let absolute = path.startsWith("/");
+  let traversalFailure;
+  while (pending.length) {
+    options.signal?.throwIfAborted();
+    if (`/${parts.join("/")}` === nullPath) throw new FsError("ENOTDIR", { path });
+    const component = pending.shift();
+    if (!component || component === ".") continue;
+    if (component === "..") {
+      parts.pop();
+      continue;
+    }
+    const candidate = `/${[...parts, component].join("/")}`;
+    if (candidate !== deviceDirectory && candidate !== nullPath && (followFinal && aliases || pending.length)) {
+      const lookup = absolute ? candidate : candidate.slice(1);
+      let stat;
+      try {
+        if (typeof filesystem.lstat !== "function") throw new FsError("ENOTSUP", { path });
+        stat = await filesystem.lstat(lookup, options);
+      } catch (error) {
+        options.signal?.throwIfAborted();
+        if (isFsError(error, "ENOTSUP") && links === 0 && lexical !== nullPath && lexical !== deviceDirectory && lexical !== "/") return lexical;
+        if (!isFsError(error, "ENOENT")) throw error;
+        if (pending.length) traversalFailure ??= error;
+      }
+      options.signal?.throwIfAborted();
+      if (stat?.type === "symlink") {
+        if (typeof filesystem.readlink !== "function") throw new FsError("ENOTSUP", { path });
+        if (++links > 40) throw new FsError("ELOOP", { path });
+        const target = await filesystem.readlink(lookup, options);
+        options.signal?.throwIfAborted();
+        validatePath(target);
+        expanded += target.length;
+        if (expanded > 65536) throw new FsError("ENAMETOOLONG", { path });
+        if (target.startsWith("/")) {
+          parts.length = 0;
+          absolute = true;
+        }
+        pending.unshift(...target.split("/"));
+        continue;
+      }
+      if (stat && pending.length && stat.type !== "directory") traversalFailure ??= new FsError("ENOTDIR", { path });
+    }
+    parts.push(component);
+  }
+  const resolved = `/${parts.join("/")}`;
+  if (traversalFailure && (resolved === nullPath || resolved === deviceDirectory || resolved === "/")) throw traversalFailure;
+  return resolved;
+}
+
+// packages/safe-fs/src/fs/devices/stream.ts
+function deviceReadStream(open) {
+  return { [Symbol.asyncIterator]() {
+    let opened;
+    let closing;
+    const iterator = () => opened ??= open().then((source) => source[Symbol.asyncIterator]());
+    const close = () => closing ??= iterator().then(async (source) => source.return ? source.return() : { done: true, value: void 0 });
+    return {
+      async next() {
+        if (closing) {
+          await closing;
+          return { done: true, value: void 0 };
+        }
+        try {
+          return await (await iterator()).next();
+        } catch (error) {
+          await finishCleanup(close, true);
+          throw error;
+        }
+      },
+      return: close
+    };
+  } };
+}
+async function drainDeviceFile(handle, signal) {
+  let failed = false;
+  let position = 0;
+  try {
+    await drainDeviceInput({ [Symbol.asyncIterator]: () => ({ async next() {
+      const value = await handle.read(position, 65536, signal ? { signal } : {});
+      if (!(value instanceof Uint8Array) || value.byteLength > 65536) throw new TypeError("Retained reads must return bounded Uint8Array chunks");
+      position += value.byteLength;
+      if (!Number.isSafeInteger(position)) throw new RangeError("Retained read position exceeds safe integer range");
+      return { done: value.byteLength === 0, value };
+    } }) }, signal);
+  } catch (error) {
+    failed = true;
+    throw error;
+  } finally {
+    await finishCleanup(async () => {
+      try {
+        await handle.close();
+      } catch (error) {
+        signal?.throwIfAborted();
+        throw error;
+      }
+    }, failed);
+  }
+  signal?.throwIfAborted();
+}
+function nextChunk(iterator, signal) {
+  signal?.throwIfAborted();
+  return new Promise((resolve, reject) => {
+    const aborted = () => {
+      signal?.removeEventListener("abort", aborted);
+      reject(signal?.reason);
+    };
+    signal?.addEventListener("abort", aborted, { once: true });
+    try {
+      Promise.resolve(iterator.next()).then((result) => {
+        signal?.removeEventListener("abort", aborted);
+        if (signal?.aborted) reject(signal.reason);
+        else resolve(result);
+      }, (error) => {
+        signal?.removeEventListener("abort", aborted);
+        reject(signal?.aborted ? signal.reason : error);
+      });
+    } catch (error) {
+      signal?.removeEventListener("abort", aborted);
+      reject(signal?.aborted ? signal.reason : error);
+    }
+  });
+}
+async function drainDeviceInput(source, signal) {
+  signal?.throwIfAborted();
+  const iterator = source[Symbol.asyncIterator]();
+  let failed = false;
+  let bytes = 0;
+  let pulls = 0;
+  try {
+    for (; ; ) {
+      const result = await nextChunk(iterator, signal);
+      signal?.throwIfAborted();
+      if (result.done) break;
+      if (!(result.value instanceof Uint8Array)) throw new TypeError("Byte sources must yield Uint8Array chunks");
+      bytes += result.value.byteLength;
+      if (++pulls >= 64 || bytes >= 65536) {
+        await new Promise((resolve) => setTimeout(resolve, 0));
+        signal?.throwIfAborted();
+        bytes = 0;
+        pulls = 0;
+      }
+    }
+  } catch (error) {
+    failed = true;
+    throw error;
+  } finally {
+    await finishCleanup(async () => {
+      try {
+        await iterator.return?.();
+      } catch (error) {
+        signal?.throwIfAborted();
+        throw error;
+      }
+    }, failed);
+  }
+  signal?.throwIfAborted();
+}
+
+// packages/safe-fs/src/fs/devices/index.ts
+var views = /* @__PURE__ */ new WeakMap();
+var deviceCapabilities = Object.freeze({
+  readOnly: false,
+  read: true,
+  stat: true,
+  realpath: true,
+  access: true,
+  readdir: false,
+  write: true,
+  append: true,
+  exclusiveCreate: true,
+  streamingRead: true,
+  retainedRead: true,
+  streamingWrite: true,
+  streamingAppend: true,
+  copy: true,
+  exclusiveCopy: true,
+  remove: false,
+  removeDirectory: false,
+  recursiveRemove: false,
+  rename: false,
+  mkdir: false,
+  recursiveMkdir: false,
+  symlinks: false,
+  hardlinks: false,
+  readlink: false,
+  permissions: false,
+  timestamps: false,
+  truncate: false,
+  randomAccessWrite: false,
+  atomicRename: false,
+  atomicRenameNoReplace: false,
+  descriptorWriteStream: true
+});
+function globalCapabilities(filesystem) {
+  const capabilities = { readOnly: false };
+  const optional = {
+    streamingRead: ["readStream"],
+    streamingWrite: ["writeStream"],
+    retainedRead: ["openReadFile"],
+    streamingAppend: ["writeStream"],
+    descriptorWriteStream: ["writeStream"],
+    symlinks: ["symlink", "readlink"],
+    hardlinks: ["link"],
+    permissions: ["chmod"],
+    timestamps: ["utimes"],
+    readlink: ["readlink"],
+    truncate: ["truncate"],
+    removeDirectory: ["rmdir"]
+  };
+  for (const key of /* @__PURE__ */ new Set([...Object.keys(filesystem.capabilities), ...Object.keys(deviceCapabilities)])) {
+    if (key === "readOnly") continue;
+    Object.defineProperty(capabilities, key, { enumerable: true, get() {
+      if (key === "copy" || key === "exclusiveCopy") return void 0;
+      let declared = filesystem.capabilities[key];
+      if (declared === true && optional[key]?.some((method) => typeof filesystem[method] !== "function")) declared = false;
+      if (key === "descriptorWriteStream" && filesystem.capabilities.streamingWrite === false) declared = false;
+      return declared === deviceCapabilities[key] ? declared : void 0;
+    } });
+  }
+  return Object.freeze(capabilities);
+}
+function reserved(path) {
+  return path === "/" || path === deviceDirectory || path === nullPath;
+}
+function nonnegative(value, path) {
+  if (value !== void 0 && (!Number.isSafeInteger(value) || value < 0)) throw new FsError("EINVAL", { path });
+}
+var DeviceFileSystem = class {
+  #filesystem;
+  capabilities;
+  #nullStat;
+  #directoryStat;
+  constructor(filesystem) {
+    this.#filesystem = filesystem;
+    this.capabilities = globalCapabilities(filesystem);
+    const identityScope = Object.freeze({});
+    this.#nullStat = Object.freeze({
+      type: "character",
+      mode: 8630,
+      size: 0,
+      allocatedBytes: 0,
+      mtimeMs: 0,
+      atimeMs: 0,
+      ctimeMs: 0,
+      birthtimeMs: 0,
+      identityScope,
+      ino: 1,
+      dev: 0,
+      nlink: 1
+    });
+    this.#directoryStat = Object.freeze({ ...this.#nullStat, type: "directory", mode: 16877, ino: 2 });
+    const methods = /* @__PURE__ */ new Map();
+    const view = new Proxy(this, {
+      set: (_target, property, value) => Reflect.set(filesystem, property, value, filesystem),
+      get(target, property) {
+        const value = Reflect.get(target, property, target);
+        if (typeof value !== "function" || property === "constructor") return value;
+        const backing = Reflect.get(filesystem, property, filesystem);
+        const cached = methods.get(property);
+        if (cached && cached.backing === backing) return cached.bound;
+        const bound = value.bind(target);
+        methods.set(property, { backing, bound });
+        return bound;
+      }
+    });
+    for (const identity of [this, view]) registerEntryView(identity, async (path, options) => {
+      const resolved = await this.#resolve(path, options);
+      if (resolved === nullPath || resolved === deviceDirectory) return {
+        filesystem: this,
+        path: resolved,
+        stat: resolved === nullPath ? this.#nullStat : this.#directoryStat,
+        readOnly: false
+      };
+      return { filesystem, path };
+    });
+    return view;
+  }
+  #resolve(path, options, followFinal = true) {
+    return resolveDevicePath(this.#filesystem, path, options, followFinal);
+  }
+  async #mutable(path, options, followFinal = true) {
+    if (reserved(await this.#resolve(path, options, followFinal))) throw new FsError("EBUSY", { path });
+  }
+  async #writeTarget(path, options) {
+    const resolved = await this.#resolve(path, options);
+    if (resolved === nullPath) {
+      if (options.flag === "wx" || options.flag === "ax") throw new FsError("EEXIST", { path });
+      if (options.flag !== void 0 && options.flag !== "w" && options.flag !== "a") throw new FsError("EINVAL", { path });
+      return true;
+    }
+    if (resolved === "/" || resolved === deviceDirectory) throw new FsError("EISDIR", { path });
+    return false;
+  }
+  canonicalizeMissingTarget(path, options = {}) {
+    options.signal?.throwIfAborted();
+    const resolved = lexicalDevicePath(path);
+    return reserved(resolved) ? resolved : this.#filesystem.canonicalizeMissingTarget?.(path, options);
+  }
+  async capabilitiesFor(path, options = {}) {
+    const resolved = await this.#resolve(path, options);
+    if (resolved === nullPath) return deviceCapabilities;
+    if (resolved === deviceDirectory) return {
+      ...deviceCapabilities,
+      readdir: true,
+      write: false,
+      append: false,
+      exclusiveCreate: false,
+      streamingWrite: false,
+      streamingAppend: false,
+      descriptorWriteStream: false,
+      retainedRead: false,
+      streamingRead: false,
+      copy: false,
+      exclusiveCopy: false
+    };
+    const capabilities = await this.#filesystem.capabilitiesFor?.(path, options) ?? this.#filesystem.capabilities;
+    const unavailable = {};
+    if (typeof this.#filesystem.readStream !== "function") unavailable.streamingRead = false;
+    if (typeof this.#filesystem.writeStream !== "function") {
+      unavailable.streamingWrite = false;
+      unavailable.streamingAppend = false;
+      unavailable.descriptorWriteStream = false;
+    }
+    if (typeof this.#filesystem.openReadFile !== "function") unavailable.retainedRead = false;
+    return Object.keys(unavailable).some((key) => capabilities[key] !== false) ? { ...capabilities, ...unavailable } : capabilities;
+  }
+  async stat(path, options = {}) {
+    const resolved = await this.#resolve(path, options);
+    if (resolved === nullPath) return { ...this.#nullStat };
+    if (resolved === deviceDirectory) return { ...this.#directoryStat };
+    return this.#filesystem.stat(path, options);
+  }
+  async lstat(path, options = {}) {
+    const resolved = await this.#resolve(path, options, false);
+    if (resolved === nullPath) return { ...this.#nullStat };
+    if (resolved === deviceDirectory) return { ...this.#directoryStat };
+    return this.#filesystem.lstat(path, options);
+  }
+  compareEntry(path, peer, peerPath, options = {}) {
+    return compareEntries(this, path, peer, peerPath, options);
+  }
+  async realpath(path, options = {}) {
+    const resolved = await this.#resolve(path, options);
+    return reserved(resolved) ? resolved : this.#filesystem.realpath(path, options);
+  }
+  async readFile(path, options = {}) {
+    const resolved = await this.#resolve(path, options);
+    if (resolved === nullPath) {
+      nonnegative(options.maxBytes, path);
+      return new Uint8Array();
+    }
+    if (resolved === deviceDirectory) throw new FsError("EISDIR", { path });
+    return this.#filesystem.readFile(path, options);
+  }
+  readStream(path, options = {}) {
+    return deviceReadStream(async () => {
+      const resolved = await this.#resolve(path, options);
+      if (resolved === nullPath) {
+        nonnegative(options.start, path);
+        nonnegative(options.endExclusive, path);
+        nonnegative(options.chunkSize, path);
+        if (options.chunkSize === 0 || options.endExclusive !== void 0 && options.endExclusive < (options.start ?? 0)) throw new FsError("EINVAL", { path });
+        return { [Symbol.asyncIterator]: () => ({ next: async () => ({ done: true, value: void 0 }) }) };
+      }
+      if (resolved === deviceDirectory) throw new FsError("EISDIR", { path });
+      if (!this.#filesystem.readStream) throw new FsError("ENOTSUP", { path });
+      return this.#filesystem.readStream(path, options);
+    });
+  }
+  async openReadFile(path, options = {}) {
+    const resolved = await this.#resolve(path, options);
+    if (resolved !== nullPath) {
+      if (resolved === deviceDirectory) throw new FsError("EISDIR", { path });
+      if (!this.#filesystem.openReadFile) throw new FsError("ENOTSUP", { path });
+      return this.#filesystem.openReadFile(path, options);
+    }
+    const stat = this.#nullStat;
+    let closed = false;
+    const check = (settings) => {
+      settings.signal?.throwIfAborted();
+      if (closed) throw new FsError("EBADF", { path });
+    };
+    return {
+      async stat(settings = {}) {
+        check(settings);
+        return { ...stat };
+      },
+      async read(position, maxBytes, settings = {}) {
+        check(settings);
+        nonnegative(position, path);
+        nonnegative(maxBytes, path);
+        return new Uint8Array();
+      },
+      async close() {
+        closed = true;
+      }
+    };
+  }
+  async writeFile(path, data, options = {}) {
+    if (await this.#writeTarget(path, options)) {
+      if (!(data instanceof Uint8Array)) throw new TypeError("File data must be Uint8Array");
+      return;
+    }
+    await this.#filesystem.writeFile(path, data, options);
+  }
+  async appendFile(path, data, options = {}) {
+    if (await this.#writeTarget(path, options)) {
+      if (!(data instanceof Uint8Array)) throw new TypeError("File data must be Uint8Array");
+      return;
+    }
+    await this.#filesystem.appendFile(path, data, options);
+  }
+  async writeStream(path, source, options = {}) {
+    if (await this.#writeTarget(path, options)) return drainDeviceInput(source, options.signal);
+    if (!this.#filesystem.writeStream) throw new FsError("ENOTSUP", { path });
+    await this.#filesystem.writeStream(path, source, options);
+  }
+  async readdir(path, options = {}) {
+    const resolved = await this.#resolve(path, options);
+    if (resolved === nullPath) throw new FsError("ENOTDIR", { path });
+    if (resolved !== "/" && resolved !== deviceDirectory) return this.#filesystem.readdir(path, options);
+    const limit = directoryEntryLimit(options, path);
+    let entries2;
+    try {
+      entries2 = await this.#filesystem.readdir(resolved, options);
+    } catch (error) {
+      options.signal?.throwIfAborted();
+      if (!isFsError(error, "ENOENT") && !isFsError(error, "ENOTDIR")) throw error;
+      entries2 = [];
+    }
+    options.signal?.throwIfAborted();
+    const merged = /* @__PURE__ */ new Map();
+    for (const entry of entries2) {
+      if (entry.name === "." || entry.name === "..") continue;
+      if (!entry.name || entry.name.includes("/") || entry.name.includes("\0")) throw new FsError("EIO", { path, message: "invalid directory entry" });
+      merged.set(entry.name, { name: entry.name, type: entry.type });
+      admitDirectoryEntries(merged.size, limit, path);
+    }
+    const name = resolved === "/" ? "dev" : "null";
+    merged.set(name, { name, type: resolved === "/" ? "directory" : "character" });
+    admitDirectoryEntries(merged.size, limit, path);
+    return [...merged.values()];
+  }
+  async mkdir(path, options = {}) {
+    const resolved = await this.#resolve(path, options);
+    if (reserved(resolved)) {
+      if (resolved !== nullPath && options.recursive) return;
+      throw new FsError("EEXIST", { path });
+    }
+    await this.#filesystem.mkdir(path, options);
+  }
+  async rm(path, options = {}) {
+    await this.#mutable(path, options, false);
+    await this.#filesystem.rm(path, options);
+  }
+  async rmdir(path, options = {}) {
+    const resolved = await this.#resolve(path, options, false);
+    if (resolved === nullPath) throw new FsError("ENOTDIR", { path });
+    if (reserved(resolved)) throw new FsError("EBUSY", { path });
+    if (!this.#filesystem.rmdir) throw new FsError("ENOTSUP", { path });
+    await this.#filesystem.rmdir(path, options);
+  }
+  async rename(source, destination, options = {}) {
+    await this.#mutable(source, options, false);
+    await this.#mutable(destination, options, false);
+    if (options.noReplace) {
+      const capabilities = await this.#filesystem.capabilitiesFor?.(destination, options) ?? this.#filesystem.capabilities;
+      options.signal?.throwIfAborted();
+      if (capabilities.atomicRenameNoReplace !== true) throw new FsError("ENOTSUP", { syscall: "rename", path: source, dest: destination });
+    }
+    await this.#filesystem.rename(source, destination, options);
+  }
+  async copyFile(source, destination, options = {}) {
+    const target = await this.#resolve(destination, options);
+    if (target === nullPath && options.exclusive) throw new FsError("EEXIST", { path: destination });
+    const origin = await this.#resolve(source, options);
+    if (target !== nullPath && origin !== nullPath) {
+      if (target === "/" || target === deviceDirectory) throw new FsError("EISDIR", { path: destination });
+      await this.#filesystem.copyFile(source, destination, options);
+      return;
+    }
+    if (target === nullPath) {
+      if (origin === nullPath) return;
+      if (origin === "/" || origin === deviceDirectory) throw new FsError("EISDIR", { path: source });
+      const capabilities = await this.capabilitiesFor(source, options);
+      if (this.#filesystem.readStream && capabilities.streamingRead !== false) {
+        await drainDeviceInput(this.#filesystem.readStream(source, options), options.signal);
+      } else if (this.#filesystem.openReadFile && capabilities.retainedRead !== false) {
+        await drainDeviceFile(await this.#filesystem.openReadFile(source, options), options.signal);
+      } else throw new FsError("ENOTSUP", { path: source });
+      return;
+    }
+    if (reserved(target)) throw new FsError("EISDIR", { path: destination });
+    await this.#filesystem.writeFile(destination, new Uint8Array(), { ...options, flag: options.exclusive ? "wx" : "w" });
+  }
+  async access(path, mode2 = 0, options = {}) {
+    const resolved = await this.#resolve(path, options);
+    if (resolved === nullPath || resolved === deviceDirectory) {
+      if (!Number.isInteger(mode2) || mode2 < 0 || mode2 > 7) throw new FsError("EINVAL", { path });
+      if (resolved === nullPath && mode2 & 1 || resolved === deviceDirectory && mode2 & 2) throw new FsError("EACCES", { path });
+      return;
+    }
+    await this.#filesystem.access(path, mode2, options);
+  }
+  async readlink(path, options = {}) {
+    if (reserved(await this.#resolve(path, options, false))) throw new FsError("EINVAL", { path });
+    if (!this.#filesystem.readlink) throw new FsError("ENOTSUP", { path });
+    return this.#filesystem.readlink(path, options);
+  }
+  async symlink(target, path, options = {}) {
+    await this.#mutable(path, options, false);
+    if (!this.#filesystem.symlink) throw new FsError("ENOTSUP", { path });
+    await this.#filesystem.symlink(target, path, options);
+  }
+  async link(existingPath, newPath, options = {}) {
+    await this.#mutable(existingPath, options, false);
+    await this.#mutable(newPath, options, false);
+    if (!this.#filesystem.link) throw new FsError("ENOTSUP", { path: newPath });
+    await this.#filesystem.link(existingPath, newPath, options);
+  }
+  async chmod(path, mode2, options = {}) {
+    await this.#mutable(path, options);
+    if (!this.#filesystem.chmod) throw new FsError("ENOTSUP", { path });
+    await this.#filesystem.chmod(path, mode2, options);
+  }
+  async utimes(path, atimeMs, mtimeMs, options = {}) {
+    await this.#mutable(path, options);
+    if (!this.#filesystem.utimes) throw new FsError("ENOTSUP", { path });
+    await this.#filesystem.utimes(path, atimeMs, mtimeMs, options);
+  }
+  async truncate(path, length, options = {}) {
+    await this.#mutable(path, options);
+    if (!this.#filesystem.truncate) throw new FsError("ENOTSUP", { path });
+    await this.#filesystem.truncate(path, length, options);
+  }
+};
+function createDeviceFileSystem(filesystem) {
+  if (filesystem instanceof DeviceFileSystem) return filesystem;
+  let view = views.get(filesystem);
+  if (!view) {
+    view = new DeviceFileSystem(filesystem);
+    views.set(filesystem, view);
+  }
+  return view;
+}
+
 // packages/safe-fs/src/fs/capabilities.ts
 function retainedReadCapabilities(filesystem, capabilities = filesystem.capabilities) {
   return typeof filesystem.openReadFile === "function" ? capabilities : { ...capabilities, retainedRead: false };
@@ -1549,6 +2119,7 @@ function readOnlyCapabilities(capabilities) {
     timestamps: false,
     descriptorWriteStream: false,
     atomicRename: false,
+    atomicRenameNoReplace: false,
     streamingWrite: false
   });
 }
@@ -1804,7 +2375,7 @@ var MountFileSystem = class _MountFileSystem {
         if (capability === "descriptorWriteStream" && backend.capabilities.streamingWrite === false) return false;
         return declared === true && optional[capability]?.some((method) => typeof backend[method] !== "function") ? false : declared;
       });
-      if (["rename", "copy", "exclusiveCopy"].includes(capability) && mounts.length > 1) return void 0;
+      if (["rename", "atomicRenameNoReplace", "copy", "exclusiveCopy"].includes(capability) && mounts.length > 1) return void 0;
       return values.every((value) => value === true) ? true : values.every((value) => value === false) ? false : void 0;
     };
     const semantics = Object.fromEntries([
@@ -1824,6 +2395,7 @@ var MountFileSystem = class _MountFileSystem {
       "removeDirectory",
       "recursiveRemove",
       "rename",
+      "atomicRenameNoReplace",
       "copy",
       "exclusiveCopy",
       "readlink",
@@ -2137,6 +2709,11 @@ var MountFileSystem = class _MountFileSystem {
       this.mutable(target);
       this.entryPath(source);
       this.entryPath(destination);
+      if (options.noReplace) {
+        const capabilities = await target.mount.backend.capabilitiesFor?.(target.local, options) ?? target.mount.backend.capabilities;
+        options.signal?.throwIfAborted();
+        if (capabilities.atomicRenameNoReplace !== true) fail("ENOTSUP");
+      }
       await origin.mount.backend.rename(origin.local, target.local, options);
     }, destination);
   }
@@ -2400,6 +2977,7 @@ var OverlayFileSystem = class {
       ...upper.readOnly === void 0 ? {} : { readOnly: upper.readOnly },
       ...effectiveAppend === void 0 ? {} : { append: effectiveAppend },
       atomicRename: false,
+      atomicRenameNoReplace: false,
       descriptorWriteStream: 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"),
@@ -2906,6 +3484,7 @@ var OverlayFileSystem = class {
   }
   async rename(source, destination, options = {}) {
     return this.run(options, async () => {
+      if (options.noReplace) fail2("ENOTSUP", source, "atomic no-replace rename is unsupported");
       this.writable(source);
       const original = await this.required(source, options, false);
       const target = await this.resolve(destination, options, false, true);
@@ -3233,6 +3812,15 @@ function withFileSystemQuota(fs, options) {
         await fs.appendFile(path, data, appendOptions);
       });
     },
+    async rename(source, destination, renameOptions) {
+      if (renameOptions?.noReplace) {
+        renameOptions.signal?.throwIfAborted();
+        const capabilities = await fs.capabilitiesFor?.(destination, renameOptions) ?? fs.capabilities;
+        renameOptions?.signal?.throwIfAborted();
+        if (capabilities.atomicRenameNoReplace !== true) throw new FsError("ENOTSUP", { syscall: "rename", path: source, dest: destination });
+      }
+      await fs.rename(source, destination, renameOptions);
+    },
     copyFile(source, destination, copyOptions) {
       return mutate(async () => {
         await assertDelta(destination, (await fs.stat(source, copyOptions)).size, copyOptions);
@@ -3388,6 +3976,17 @@ function scopeFileSystem(filesystem, charge, signal) {
           const peer = args[1];
           args[1] = originals.get(peer) ?? peer;
         }
+        if (property === "rename" && args[2]?.noReplace) return (async () => {
+          const options = args[2];
+          const capabilities = await original.capabilitiesFor?.(args[1], options) ?? original.capabilities;
+          assertOpen(options);
+          if (capabilities.atomicRenameNoReplace !== true) throw new FsError("ENOTSUP", {
+            syscall: "rename",
+            path: args[0],
+            dest: args[1]
+          });
+          return Reflect.apply(method, original, args);
+        })();
         return Reflect.apply(method, original, args);
       };
       const scoped = property === "openReadFile" ? async (...args) => wrapHandle(await dispatch(...args)) : property === "readStream" ? (...args) => wrapStream(dispatch(...args), args[1]) : operations.has(property) && property !== "canonicalizeMissingTarget" ? async (...args) => dispatch(...args) : dispatch;
@@ -3772,6 +4371,7 @@ var WebDavFileSystem = class {
     remove: true,
     recursiveRemove: true,
     rename: true,
+    atomicRenameNoReplace: false,
     copy: true,
     exclusiveCopy: true,
     readlink: false,
@@ -4710,6 +5310,10 @@ var WebDavFileSystem = class {
     }
   }
   async rename(source, destination, options = {}) {
+    if (options.noReplace) {
+      options.signal?.throwIfAborted();
+      fail3("ENOTSUP", "rename", source, "atomic no-replace rename is unsupported");
+    }
     await this.transfer("MOVE", source, destination, options);
   }
   async copyFile(source, destination, options = {}) {
@@ -4793,7 +5397,7 @@ function predicates(type) {
     isDirectory: () => type === "directory",
     isSymbolicLink: () => type === "symlink",
     isBlockDevice: () => false,
-    isCharacterDevice: () => false,
+    isCharacterDevice: () => type === "character",
     isFIFO: () => false,
     isSocket: () => false
   };
@@ -4802,7 +5406,7 @@ function bridgeStats(stat) {
   return {
     dev: stat.dev ?? 0,
     ino: stat.ino ?? 0,
-    mode: stat.mode & 4095 | (stat.type === "directory" ? 16384 : stat.type === "symlink" ? 40960 : 32768),
+    mode: stat.mode & 4095 | (stat.type === "directory" ? 16384 : stat.type === "symlink" ? 40960 : stat.type === "character" ? 8192 : 32768),
     nlink: stat.nlink ?? 1,
     uid: stat.uid ?? 0,
     gid: stat.gid ?? 0,
@@ -5422,6 +6026,8 @@ export {
   defaultMemoryFileSystemLimits,
   MemoryFileSystem,
   createMemoryFileSystem,
+  DeviceFileSystem,
+  createDeviceFileSystem,
   ReadOnlyFileSystem,
   createReadOnlyFileSystem,
   MountFileSystem,
@@ -5434,4 +6040,4 @@ export {
   WebDavFileSystem,
   createFsBridge
 };
-//# sourceMappingURL=chunk-I3HSJDAA.js.map
+//# sourceMappingURL=chunk-QK4IEGRO.js.map