Method openSync

lib/internal/vfs/providers/memory.js:494–545

(path, flags, mode)

  }

  openSync(path, flags, mode) {
    const normalized = this.#normalizePath(path);

    // Normalize numeric flags to string
    flags = normalizeFlags(flags);

    // Handle create and exclusive modes
    const isCreate = flags === 'w' || flags === 'w+' ||
                     flags === 'a' || flags === 'a+' ||
                     flags === 'wx' || flags === 'wx+' ||
                     flags === 'ax' || flags === 'ax+';
    const isExclusive = flags === 'wx' || flags === 'wx+' ||
                        flags === 'ax' || flags === 'ax+';
    const isWritable = flags !== 'r';

    // Check readonly for any writable mode
    if (this.readonly && isWritable) {
      throw createEROFS('open', path);
    }

    let entry;
    try {
      entry = this.#getEntry(normalized, 'open');
      // Exclusive flag: file must not exist
      if (isExclusive) {
        throw createEEXIST('open', path);
      }
    } catch (err) {
      if (err.code !== 'ENOENT' || !isCreate) throw err;
      // Create the file
      const parent = this.#ensureParent(normalized, false, 'open');
      const name = pathPosix.basename(normalized);
      entry = new MemoryEntry(TYPE_FILE, { mode });
      entry.content = Buffer.alloc(0);
      parent.children.set(name, entry);
      const now = DateNow();
      parent.mtime = now;
      parent.ctime = now;
    }

    if (entry.isDirectory()) {
      throw createEISDIR('open', path);
    }

    if (entry.isSymbolicLink()) {
      // Should have been resolved already, but just in case
      throw createEINVAL('open', path);
    }

    const getStats = (size) => this.#createStats(entry, size);
    return new MemoryFileHandle(normalized, flags, mode ?? entry.mode, entry.content, entry, getStats);
  }

  async open(path, flags, mode) {
    return this.openSync(path, flags, mode);