You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@opendal.apache.org by xu...@apache.org on 2026/08/29 14:46:02 UTC

(opendal) branch xuanwo/compact-metadata created (now 81afb6b106)

This is an automated email from the ASF dual-hosted git repository.

Xuanwo pushed a change to branch xuanwo/compact-metadata
in repository https://gitbox.apache.org/repos/asf/opendal.git


      at 81afb6b106 refactor!: compact metadata and operation arguments

This branch includes the following new commits:

     new 81afb6b106 refactor!: compact metadata and operation arguments

The 1 revisions listed above as "new" are entirely new to this
repository and will be described in separate emails.  The revisions
listed as "add" were already present in the repository and have only
been added to this reference.



(opendal) 01/01: refactor!: compact metadata and operation arguments

Posted by xu...@apache.org.
This is an automated email from the ASF dual-hosted git repository.

Xuanwo pushed a commit to branch xuanwo/compact-metadata
in repository https://gitbox.apache.org/repos/asf/opendal.git

commit 81afb6b106330205c67dff5466c7b59c6bb76be5
Author: Xuanwo <gi...@xuanwo.io>
AuthorDate: Sat Aug 29 22:45:29 2026 +0800

    refactor!: compact metadata and operation arguments
---
 bindings/c/src/metadata.rs                         |   11 +-
 bindings/cpp/src/test_support.rs                   |   16 +-
 bindings/nodejs/src/lib.rs                         |    7 +-
 bindings/python/src/metadata.rs                    |    9 +-
 .../src/docs/rfcs/8147_write_if_not_changed.md     |   29 +-
 .../8194_compact_metadata_and_operation_args.md    |   15 +-
 core/core/src/docs/upgrade.md                      |   12 +
 core/core/src/layers/complete.rs                   |   96 +-
 core/core/src/layers/correctness_check.rs          |   30 +-
 core/core/src/layers/simulate.rs                   |   54 +-
 core/core/src/raw/http_util/header.rs              |   22 +-
 core/core/src/raw/oio/copy/api.rs                  |    6 +-
 core/core/src/raw/oio/copy/block_copy.rs           |   15 +-
 core/core/src/raw/oio/copy/multipart_copy.rs       |   15 +-
 core/core/src/raw/oio/entry.rs                     |   52 +-
 core/core/src/raw/oio/list/flat_list.rs            |    5 +-
 core/core/src/raw/oio/write/append_write.rs        |    8 +-
 core/core/src/raw/oio/write/block_write.rs         |    4 +-
 core/core/src/raw/oio/write/multipart_write.rs     |   12 +-
 core/core/src/raw/oio/write/position_write.rs      |    2 +-
 core/core/src/raw/ops.rs                           | 1354 +++++++++++---------
 core/core/src/services/memory/backend.rs           |    6 +-
 core/core/src/services/memory/lister.rs            |    5 +-
 core/core/src/services/memory/writer.rs            |   14 +-
 core/core/src/types/compact.rs                     |  321 +++++
 core/core/src/types/context/read.rs                |   18 +-
 core/core/src/types/context/write.rs               |    2 +-
 core/core/src/types/copy.rs                        |    5 +-
 core/core/src/types/delete/deleter.rs              |   19 +-
 core/core/src/types/delete/input.rs                |    7 +-
 core/core/src/types/entry.rs                       |   22 +-
 core/core/src/types/metadata.rs                    | 1056 ++++++++++-----
 core/core/src/types/mod.rs                         |    7 +-
 core/core/src/types/operator/operator.rs           |   69 +-
 core/core/src/types/read/futures_async_reader.rs   |   12 +-
 core/core/src/types/read/reader.rs                 |    8 +-
 core/layers/concurrent-limit/src/lib.rs            |   16 +-
 core/layers/foyer/src/full.rs                      |   33 +-
 core/layers/foyer/src/lib.rs                       |   13 +-
 core/layers/immutable-index/src/lib.rs             |    2 +-
 core/layers/mime-guess/src/lib.rs                  |   28 +-
 core/layers/retry/src/lib.rs                       |   24 +-
 core/layers/route/src/lib.rs                       |    4 +-
 core/services/aliyun-drive/src/backend.rs          |   30 +-
 core/services/aliyun-drive/src/lister.rs           |   27 +-
 core/services/aliyun-drive/src/writer.rs           |    6 +-
 core/services/alluxio/src/core.rs                  |   10 +-
 core/services/alluxio/src/writer.rs                |    4 +-
 core/services/azblob/src/backend.rs                |    8 +-
 core/services/azblob/src/copier.rs                 |   13 +-
 core/services/azblob/src/core.rs                   |    9 +-
 core/services/azblob/src/lister.rs                 |   17 +-
 core/services/azblob/src/writer.rs                 |   16 +-
 core/services/azdls/src/backend.rs                 |    2 +-
 core/services/azdls/src/core.rs                    |   22 +-
 core/services/azdls/src/lister.rs                  |   13 +-
 core/services/azdls/src/writer.rs                  |   24 +-
 core/services/azfile/src/backend.rs                |    6 +-
 core/services/azfile/src/lister.rs                 |   20 +-
 core/services/azfile/src/writer.rs                 |   20 +-
 core/services/b2/src/backend.rs                    |    4 +-
 core/services/b2/src/core.rs                       |   16 +-
 core/services/b2/src/writer.rs                     |   10 +-
 core/services/cacache/src/backend.rs               |    8 +-
 core/services/cacache/src/reader.rs                |    6 +-
 core/services/cacache/src/writer.rs                |    6 +-
 core/services/cloudflare-kv/src/backend.rs         |   14 +-
 core/services/cloudflare-kv/src/lister.rs          |   29 +-
 core/services/cloudflare-kv/src/reader.rs          |    6 +-
 core/services/cloudflare-kv/src/writer.rs          |   10 +-
 core/services/compfs/src/backend.rs                |    9 +-
 core/services/compfs/src/lister.rs                 |   16 +-
 core/services/compfs/src/writer.rs                 |    2 +-
 core/services/cos/src/backend.rs                   |   10 +-
 core/services/cos/src/lister.rs                    |   44 +-
 core/services/cos/src/writer.rs                    |   17 +-
 core/services/d1/src/backend.rs                    |   10 +-
 core/services/d1/src/reader.rs                     |    6 +-
 core/services/d1/src/writer.rs                     |    6 +-
 core/services/dashmap/src/backend.rs               |    2 +-
 core/services/dashmap/src/reader.rs                |    6 +-
 core/services/dashmap/src/writer.rs                |   15 +-
 core/services/dbfs/src/backend.rs                  |   16 +-
 core/services/dbfs/src/lister.rs                   |   14 +-
 core/services/dbfs/src/writer.rs                   |    4 +-
 core/services/dropbox/src/backend.rs               |   12 +-
 core/services/dropbox/src/lister.rs                |    8 +-
 core/services/dropbox/src/writer.rs                |   14 +-
 core/services/etcd/src/backend.rs                  |    8 +-
 core/services/etcd/src/lister.rs                   |    3 +-
 core/services/etcd/src/reader.rs                   |    6 +-
 core/services/etcd/src/writer.rs                   |    6 +-
 core/services/foundationdb/src/backend.rs          |   10 +-
 core/services/foundationdb/src/reader.rs           |    6 +-
 core/services/foundationdb/src/writer.rs           |    6 +-
 core/services/foyer/src/backend.rs                 |   10 +-
 core/services/foyer/src/reader.rs                  |    6 +-
 core/services/foyer/src/writer.rs                  |    6 +-
 core/services/fs/src/backend.rs                    |    2 +-
 core/services/fs/src/core.rs                       |   10 +-
 core/services/fs/src/lister.rs                     |   11 +-
 core/services/fs/src/writer.rs                     |   23 +-
 core/services/ftp/src/backend.rs                   |    8 +-
 core/services/ftp/src/lister.rs                    |   16 +-
 core/services/ftp/src/reader.rs                    |    2 +-
 core/services/ftp/src/writer.rs                    |    2 +-
 core/services/gcs-grpc/src/backend.rs              |    2 +-
 core/services/gcs-grpc/src/core.rs                 |   22 +-
 core/services/gcs-grpc/src/lister.rs               |    6 +-
 core/services/gcs-grpc/src/writer.rs               |   11 +-
 core/services/gcs/src/copier.rs                    |    5 +-
 core/services/gcs/src/core.rs                      |  129 +-
 core/services/gcs/src/lister.rs                    |   18 +-
 core/services/gcs/src/reader.rs                    |    6 +-
 core/services/gcs/src/writer.rs                    |    8 +-
 core/services/gdrive/src/backend.rs                |  108 +-
 core/services/gdrive/src/core.rs                   |   56 +-
 core/services/gdrive/src/lister.rs                 |   21 +-
 core/services/gdrive/src/writer.rs                 |   12 +-
 core/services/ghac/src/writer.rs                   |   12 +-
 core/services/github/src/backend.rs                |   10 +-
 core/services/github/src/lister.rs                 |   22 +-
 core/services/github/src/writer.rs                 |    8 +-
 core/services/goosefs/src/core.rs                  |   12 +-
 core/services/goosefs/src/lister.rs                |    6 +-
 core/services/goosefs/src/writer.rs                |   12 +-
 core/services/gridfs/src/backend.rs                |   10 +-
 core/services/gridfs/src/reader.rs                 |    6 +-
 core/services/gridfs/src/writer.rs                 |    6 +-
 core/services/hdfs-native/src/core.rs              |    8 +-
 core/services/hdfs-native/src/lister.rs            |   21 +-
 core/services/hdfs-native/src/writer.rs            |    6 +-
 core/services/hdfs/src/core.rs                     |    8 +-
 core/services/hdfs/src/lister.rs                   |   20 +-
 core/services/hdfs/src/writer.rs                   |    6 +-
 core/services/hf/src/backend.rs                    |    4 +-
 core/services/hf/src/core.rs                       |   12 +-
 core/services/hf/src/reader.rs                     |    6 +-
 core/services/hf/src/writer.rs                     |    6 +-
 core/services/http/src/backend.rs                  |    4 +-
 core/services/ipfs/src/core.rs                     |   24 +-
 core/services/ipmfs/src/backend.rs                 |    8 +-
 core/services/ipmfs/src/lister.rs                  |   15 +-
 core/services/ipmfs/src/writer.rs                  |    4 +-
 core/services/koofr/src/backend.rs                 |   14 +-
 core/services/koofr/src/lister.rs                  |   12 +-
 core/services/koofr/src/writer.rs                  |   10 +-
 core/services/lakefs/src/backend.rs                |    4 +-
 core/services/lakefs/src/core.rs                   |   12 +-
 core/services/lakefs/src/lister.rs                 |    8 +-
 core/services/memcached/src/backend.rs             |   10 +-
 core/services/memcached/src/reader.rs              |    6 +-
 core/services/memcached/src/writer.rs              |    6 +-
 core/services/mini_moka/src/backend.rs             |   14 +-
 core/services/mini_moka/src/reader.rs              |    6 +-
 core/services/mini_moka/src/writer.rs              |   15 +-
 core/services/moka/src/backend.rs                  |   12 +-
 core/services/moka/src/reader.rs                   |    6 +-
 core/services/moka/src/writer.rs                   |   13 +-
 core/services/mongodb/src/backend.rs               |   10 +-
 core/services/mongodb/src/reader.rs                |    6 +-
 core/services/mongodb/src/writer.rs                |    6 +-
 core/services/monoiofs/src/backend.rs              |   10 +-
 core/services/monoiofs/src/writer.rs               |    8 +-
 core/services/mysql/src/backend.rs                 |   10 +-
 core/services/mysql/src/lister.rs                  |    2 +-
 core/services/mysql/src/reader.rs                  |    6 +-
 core/services/mysql/src/writer.rs                  |    6 +-
 core/services/obs/src/backend.rs                   |   13 +-
 core/services/obs/src/lister.rs                    |    8 +-
 core/services/obs/src/writer.rs                    |   24 +-
 core/services/onedrive/src/backend.rs              |    2 +-
 core/services/onedrive/src/core.rs                 |   10 +-
 core/services/onedrive/src/lister.rs               |   23 +-
 core/services/onedrive/src/writer.rs               |   22 +-
 core/services/opfs/src/backend.rs                  |    8 +-
 core/services/opfs/src/lister.rs                   |    5 +-
 core/services/opfs/src/writer.rs                   |    4 +-
 core/services/oss/src/backend.rs                   |   11 +-
 core/services/oss/src/core.rs                      |    6 +-
 core/services/oss/src/deleter.rs                   |    7 +-
 core/services/oss/src/lister.rs                    |   46 +-
 core/services/oss/src/writer.rs                    |   10 +-
 core/services/pcloud/src/backend.rs                |    2 +-
 core/services/pcloud/src/core.rs                   |   20 +-
 core/services/pcloud/src/writer.rs                 |    2 +-
 core/services/persy/src/backend.rs                 |   10 +-
 core/services/persy/src/reader.rs                  |    6 +-
 core/services/persy/src/writer.rs                  |    6 +-
 core/services/postgresql/src/backend.rs            |   10 +-
 core/services/postgresql/src/reader.rs             |    6 +-
 core/services/postgresql/src/writer.rs             |    6 +-
 core/services/redb/src/backend.rs                  |   10 +-
 core/services/redb/src/reader.rs                   |    6 +-
 core/services/redb/src/writer.rs                   |    6 +-
 core/services/redis/src/backend.rs                 |   10 +-
 core/services/redis/src/reader.rs                  |   14 +-
 core/services/redis/src/writer.rs                  |    6 +-
 core/services/rocksdb/src/backend.rs               |   10 +-
 core/services/rocksdb/src/lister.rs                |    8 +-
 core/services/rocksdb/src/reader.rs                |    6 +-
 core/services/rocksdb/src/writer.rs                |    6 +-
 core/services/s3/src/backend.rs                    |   33 +-
 core/services/s3/src/copier.rs                     |   25 +-
 core/services/s3/src/lister.rs                     |   56 +-
 core/services/s3/src/reader.rs                     |    8 +-
 core/services/s3/src/writer.rs                     |   17 +-
 core/services/seafile/src/backend.rs               |    2 +-
 core/services/seafile/src/core.rs                  |   14 +-
 core/services/seafile/src/lister.rs                |   12 +-
 core/services/seafile/src/writer.rs                |    2 +-
 core/services/sftp/src/backend.rs                  |    2 +-
 core/services/sftp/src/core.rs                     |    8 +-
 core/services/sftp/src/writer.rs                   |    2 +-
 core/services/sled/src/backend.rs                  |   10 +-
 core/services/sled/src/lister.rs                   |    8 +-
 core/services/sled/src/reader.rs                   |    6 +-
 core/services/sled/src/writer.rs                   |    6 +-
 core/services/sqlite/src/backend.rs                |   12 +-
 core/services/sqlite/src/reader.rs                 |    6 +-
 core/services/sqlite/src/writer.rs                 |    6 +-
 core/services/surrealdb/src/backend.rs             |   10 +-
 core/services/surrealdb/src/reader.rs              |    6 +-
 core/services/surrealdb/src/writer.rs              |    6 +-
 core/services/swift/src/backend.rs                 |   10 +-
 core/services/swift/src/lister.rs                  |   14 +-
 core/services/swift/src/writer.rs                  |    8 +-
 core/services/tikv/src/backend.rs                  |   10 +-
 core/services/tikv/src/reader.rs                   |    6 +-
 core/services/tikv/src/writer.rs                   |    6 +-
 core/services/tos/src/backend.rs                   |   10 +-
 core/services/tos/src/copier.rs                    |   14 +-
 core/services/tos/src/core.rs                      |    6 +-
 core/services/tos/src/deleter.rs                   |   11 +-
 core/services/tos/src/lister.rs                    |   46 +-
 core/services/tos/src/writer.rs                    |   19 +-
 core/services/upyun/src/backend.rs                 |    2 +-
 core/services/upyun/src/core.rs                    |   14 +-
 core/services/upyun/src/lister.rs                  |   12 +-
 core/services/upyun/src/writer.rs                  |    4 +-
 core/services/vercel-artifacts/src/writer.rs       |    4 +-
 core/services/vercel-blob/src/backend.rs           |    2 +-
 core/services/vercel-blob/src/core.rs              |   12 +-
 core/services/vercel-blob/src/writer.rs            |    4 +-
 core/services/webdav/src/backend.rs                |    4 +-
 core/services/webdav/src/core.rs                   |   18 +-
 core/services/webdav/src/writer.rs                 |   14 +-
 core/services/webhdfs/src/backend.rs               |   14 +-
 core/services/webhdfs/src/lister.rs                |   16 +-
 core/services/webhdfs/src/writer.rs                |    8 +-
 core/services/yandex-disk/src/backend.rs           |    4 +-
 core/services/yandex-disk/src/core.rs              |   12 +-
 core/services/yandex-disk/src/writer.rs            |    2 +-
 core/tests/behavior/async_delete.rs                |   31 +-
 core/tests/behavior/async_write.rs                 |    5 +-
 integrations/object_store/src/service/core.rs      |   20 +-
 integrations/object_store/src/service/writer.rs    |    8 +-
 integrations/object_store/src/store.rs             |    4 +-
 258 files changed, 3790 insertions(+), 2235 deletions(-)

diff --git a/bindings/c/src/metadata.rs b/bindings/c/src/metadata.rs
index fe0b4254e2..167b61d5ff 100644
--- a/bindings/c/src/metadata.rs
+++ b/bindings/c/src/metadata.rs
@@ -16,7 +16,6 @@
 // under the License.
 
 use ::opendal as core;
-use std::collections::HashMap;
 use std::ffi::{c_char, c_void, CString};
 use std::ptr;
 
@@ -38,18 +37,14 @@ struct opendal_metadata_user_metadata_inner {
 }
 
 impl opendal_metadata_user_metadata_inner {
-    fn new(user_metadata: &HashMap<String, String>) -> Self {
+    fn new(user_metadata: core::UserMetadata<'_>) -> Self {
         let mut keys = Vec::with_capacity(user_metadata.len());
         let mut values = Vec::with_capacity(user_metadata.len());
         let mut pairs = Vec::with_capacity(user_metadata.len());
 
         for (key, value) in user_metadata {
-            keys.push(
-                CString::new(key.as_str()).expect("user metadata key should not contain nul"),
-            );
-            values.push(
-                CString::new(value.as_str()).expect("user metadata value should not contain nul"),
-            );
+            keys.push(CString::new(key).expect("user metadata key should not contain nul"));
+            values.push(CString::new(value).expect("user metadata value should not contain nul"));
 
             pairs.push(opendal_metadata_user_metadata_pair {
                 key: keys.last().expect("key has just been pushed").as_ptr(),
diff --git a/bindings/cpp/src/test_support.rs b/bindings/cpp/src/test_support.rs
index a0403203a6..95d7424910 100644
--- a/bindings/cpp/src/test_support.rs
+++ b/bindings/cpp/src/test_support.rs
@@ -100,9 +100,9 @@ impl Service for HangingService {
     }
 
     async fn stat(&self, _: &OperationContext, _: &str, _: OpStat) -> Result<RpStat> {
-        Ok(RpStat::new(
-            Metadata::new(EntryMode::FILE).with_content_length(13),
-        ))
+        let mut metadata = Metadata::builder(EntryMode::FILE);
+        metadata.content_length(13);
+        Ok(RpStat::new(metadata.build()))
     }
 
     fn read(&self, _: &OperationContext, _: &str, _: OpRead) -> Result<Self::Reader> {
@@ -205,9 +205,9 @@ impl Service for RetryableService {
     }
 
     async fn stat(&self, _: &OperationContext, _: &str, _: OpStat) -> Result<RpStat> {
-        Ok(RpStat::new(
-            Metadata::new(EntryMode::FILE).with_content_length(13),
-        ))
+        let mut metadata = Metadata::builder(EntryMode::FILE);
+        metadata.content_length(13);
+        Ok(RpStat::new(metadata.build()))
     }
 
     fn read(&self, _: &OperationContext, _: &str, _: OpRead) -> Result<Self::Reader> {
@@ -272,7 +272,9 @@ struct RetryableReader {
 
 impl oio::StreamRead for RetryableReader {
     async fn open(&self, range: BytesRange) -> Result<(RpRead, Box<dyn oio::ReadStreamDyn>)> {
-        let rp = RpRead::new(Metadata::new(EntryMode::FILE).with_content_length(0));
+        let mut metadata = Metadata::builder(EntryMode::FILE);
+        metadata.content_length(0);
+        let rp = RpRead::new(metadata.build());
         Ok((
             rp,
             Box::new(RetryableReadStream {
diff --git a/bindings/nodejs/src/lib.rs b/bindings/nodejs/src/lib.rs
index a13df40803..c1d7d1f046 100644
--- a/bindings/nodejs/src/lib.rs
+++ b/bindings/nodejs/src/lib.rs
@@ -964,7 +964,12 @@ impl Metadata {
     /// User Metadata of this object.
     #[napi(getter)]
     pub fn user_metadata(&self) -> Option<HashMap<String, String>> {
-        self.0.user_metadata().cloned()
+        self.0.user_metadata().map(|metadata| {
+            metadata
+                .into_iter()
+                .map(|(key, value)| (key.to_string(), value.to_string()))
+                .collect()
+        })
     }
 
     /// ETag of this object.
diff --git a/bindings/python/src/metadata.rs b/bindings/python/src/metadata.rs
index a093e0f67a..c4aca10a82 100644
--- a/bindings/python/src/metadata.rs
+++ b/bindings/python/src/metadata.rs
@@ -154,8 +154,13 @@ impl Metadata {
 
     /// The user-defined metadata of this entry.
     #[getter]
-    pub fn user_metadata(&self) -> Option<&HashMap<String, String>> {
-        self.0.user_metadata()
+    pub fn user_metadata(&self) -> Option<HashMap<String, String>> {
+        self.0.user_metadata().map(|metadata| {
+            metadata
+                .into_iter()
+                .map(|(key, value)| (key.to_string(), value.to_string()))
+                .collect()
+        })
     }
     pub fn __repr__(&self) -> String {
         let mut parts = vec![];
diff --git a/core/core/src/docs/rfcs/8147_write_if_not_changed.md b/core/core/src/docs/rfcs/8147_write_if_not_changed.md
index c85ecd5210..08c03ed628 100644
--- a/core/core/src/docs/rfcs/8147_write_if_not_changed.md
+++ b/core/core/src/docs/rfcs/8147_write_if_not_changed.md
@@ -61,9 +61,9 @@ Callers may also construct expected metadata from identities obtained through
 another trusted channel:
 
 ```rust,ignore
-let expected = Metadata::default()
-    .with_etag(saved_etag)
-    .with_version(saved_version);
+let mut expected = Metadata::builder(EntryMode::Unknown);
+expected.etag(saved_etag).version(saved_version);
+let expected = expected.build();
 ```
 
 Preserving both fields keeps externally stored metadata portable across
@@ -89,8 +89,9 @@ as `"*"` are outside the portable delete contract. Multiple supplied conditions
 are combined with logical AND.
 
 `if_not_changed` is a derived condition. At the shared write, delete, or copy
-entry point, OpenDAL uses the effective capabilities after all layers and
-lowers it before raw service dispatch:
+entry point, OpenDAL first freezes the public options into raw arguments. It
+then uses the effective capabilities after all layers and selects the primitive
+condition before raw service dispatch:
 
 1. If the operation supports `if_version_match` and `meta.version()` exists,
    use `if_version_match(version)`.
@@ -100,14 +101,16 @@ lowers it before raw service dispatch:
 4. If a primitive is supported but metadata contains no usable identity for
    any supported primitive, return `ConfigInvalid`.
 
-Raw operations and services never receive `if_not_changed`; they only receive
-the selected primitive. Version match takes precedence because a version is
-intended to identify an object revision and avoids ETag ABA where the service
-can enforce it. Adding version-match support may therefore make a call carrying
-both fields stricter, but never weaker. Other metadata fields do not
-participate. OpenDAL does not validate provenance, path, or storage namespace,
-so the caller must associate externally constructed metadata with the correct
-target.
+Raw arguments preserve the complete owned `if_not_changed` metadata together
+with the selected primitive. Services enforce the selected primitive; retaining
+the logical condition lets future shared dispatch logic use another identity
+without changing the public option or losing caller intent during structural
+conversion. Version match takes precedence because a version is intended to
+identify an object revision and avoids ETag ABA where the service can enforce
+it. Adding version-match support may therefore make a call carrying both fields
+stricter, but never weaker. Other metadata fields do not participate today.
+OpenDAL does not validate provenance, path, or storage namespace, so the caller
+must associate externally constructed metadata with the correct target.
 
 OpenDAL preserves explicit target conditions and version selectors while
 lowering `if_not_changed`. If the selected primitive match field already
diff --git a/core/core/src/docs/rfcs/8194_compact_metadata_and_operation_args.md b/core/core/src/docs/rfcs/8194_compact_metadata_and_operation_args.md
index 3aa4083319..2bc339a448 100644
--- a/core/core/src/docs/rfcs/8194_compact_metadata_and_operation_args.md
+++ b/core/core/src/docs/rfcs/8194_compact_metadata_and_operation_args.md
@@ -1,7 +1,7 @@
 - Proposal Name: `compact_metadata_and_operation_args`
 - Start Date: 2026-08-29
 - RFC PR: [apache/opendal#8194](https://github.com/apache/opendal/pull/8194)
-- Tracking Issue: [apache/opendal#0000](https://github.com/apache/opendal/issues/0000)
+- Tracking Issue: [apache/opendal#8195](https://github.com/apache/opendal/issues/8195)
 
 # Summary
 
@@ -262,10 +262,10 @@ struct MetadataHeader {
 struct MetadataFlags(u16);
 ```
 
-`MetadataFlags` encodes mode, scalar presence, deletion state, the three states
-of `is_current`, and whether user metadata was supplied. Separate seconds and
-nanoseconds preserve the range and precision of the existing `last_modified`
-field.
+`MetadataFlags` encodes mode, scalar presence, deletion state, and the three
+states of `is_current`. The value-block bitmap distinguishes absent user
+metadata from an explicitly empty map. Separate seconds and nanoseconds preserve
+the range and precision of the existing `last_modified` field.
 
 On 64-bit targets, `MetadataHeader` is 24 bytes. `Arc<[u8]>` is a 16-byte fat
 pointer, and `Option<Arc<[u8]>>` has the same size because `None` uses the null
@@ -440,5 +440,6 @@ empty-versus-absent user metadata, field-for-field options conversion,
 dispatch-time conditional lowering, and required file content length. Boundary
 tests prove that a `u16::MAX`-byte block succeeds and the next byte panics before
 encoding. Prototype benchmarks cover construction, retained heap, lookup, clone,
-builder transformation, raw operations, and scalar placement. The implementation
-must check in equivalent benchmarks with the optimized types.
+builder transformation, raw operations, and scalar placement. Their results stay
+in this RFC; the long-term test suite keeps the layout and behavioral invariants
+without carrying the prototype benchmark harness or rejected representations.
diff --git a/core/core/src/docs/upgrade.md b/core/core/src/docs/upgrade.md
index 9b3594242e..5ad3204d7b 100644
--- a/core/core/src/docs/upgrade.md
+++ b/core/core/src/docs/upgrade.md
@@ -29,6 +29,14 @@ Operator runtime resources now live in `OperationContext`, which is exported fro
 
 `BytesRange` is now part of the public type layer. Reader APIs accept values convertible into `BytesRange`, and suffix reads can be requested with `BytesRange::suffix(size)`. Code that imported raw HTTP range helpers should use `opendal::BytesRange` instead.
 
+### `Metadata` uses immutable builder-based construction
+
+`Metadata::new`, `Default`, `set_*`, and `with_*` have been removed. Construct metadata with `Metadata::builder(mode)` and call `build()` after setting fields. Consume existing metadata with `into_builder()` when creating a modified value.
+
+`Metadata::user_metadata()` now returns a borrowed `UserMetadata` view instead of `&HashMap<String, String>`. The view supports `get`, `len`, `is_empty`, and `IntoIterator`; collect owned string pairs at boundaries that require a map.
+
+Every file `Metadata` returned through an `Operator` must contain an explicit full-object content length. Raw services that omit it now return `Unexpected` at the completion boundary.
+
 ## Raw API
 
 ### Services and layers use the new composition boundary
@@ -45,6 +53,10 @@ Out-of-tree layers must implement `Layer::apply_service` and, when they replace
 
 The unused `raw::AtomicContentLength`, `raw::PathCacher`, and `raw::PathQuery` helpers have been removed. The `internal-path-cache` feature has also been removed.
 
+### Raw operation arguments are frozen from public options
+
+Public `with_*` mutation methods have been removed from `OpRead`, `OpStat`, `OpWrite`, `OpDelete`, `OpCopy`, `OpList`, and `OpRestore`. Construct non-empty raw arguments by converting the corresponding public `*Options`; `new` and `Default` remain available for empty arguments. `OpWrite::user_metadata()` returns the same borrowed `UserMetadata` view as `Metadata`.
+
 # Upgrade to v0.57
 
 ## Public API
diff --git a/core/core/src/layers/complete.rs b/core/core/src/layers/complete.rs
index 2c29185001..0b80bff97e 100644
--- a/core/core/src/layers/complete.rs
+++ b/core/core/src/layers/complete.rs
@@ -120,7 +120,9 @@ impl Service for CompleteService {
     }
 
     async fn stat(&self, ctx: &OperationContext, path: &str, args: OpStat) -> Result<RpStat> {
-        self.inner.stat(ctx, path, args).await
+        let metadata = self.inner.stat(ctx, path, args).await?.into_metadata();
+        ensure_file_content_length(&metadata, "CompleteService::stat")?;
+        Ok(RpStat::new(metadata))
     }
 
     fn delete(&self, ctx: &OperationContext) -> Result<Self::Deleter> {
@@ -153,13 +155,14 @@ impl CompleteLister {
         Self { inner, ctx, srv }
     }
 
-    async fn ensure_file_content_length(&self, entry: &mut oio::Entry) -> Result<()> {
+    async fn ensure_file_content_length(&self, entry: oio::Entry) -> Result<oio::Entry> {
         let path = entry.path().to_string();
         let version = entry.metadata().version().map(str::to_owned);
-        let mut op = OpStat::new();
-        if let Some(version) = version.as_deref() {
-            op = op.with_version(version);
+        let op = options::StatOptions {
+            version,
+            ..Default::default()
         }
+        .into();
 
         let stat_metadata = self.srv.stat(&self.ctx, &path, op).await?.into_metadata();
         if !stat_metadata.has_content_length() {
@@ -172,17 +175,17 @@ impl CompleteLister {
             .with_context("path", path));
         }
 
-        entry
-            .metadata_mut()
-            .set_content_length(stat_metadata.content_length());
-        Ok(())
+        let (path, metadata) = entry.into_parts();
+        let mut builder = metadata.into_builder();
+        builder.content_length(stat_metadata.content_length());
+        Ok(oio::Entry::with(path, builder.build()))
     }
 }
 
 impl oio::List for CompleteLister {
     async fn next(&mut self) -> Result<Option<oio::Entry>> {
         loop {
-            let Some(mut entry) = self.inner.next().await? else {
+            let Some(entry) = self.inner.next().await? else {
                 return Ok(None);
             };
 
@@ -193,8 +196,8 @@ impl oio::List for CompleteLister {
                 return Ok(Some(entry));
             }
 
-            match self.ensure_file_content_length(&mut entry).await {
-                Ok(()) => return Ok(Some(entry)),
+            match self.ensure_file_content_length(entry).await {
+                Ok(entry) => return Ok(Some(entry)),
                 Err(err) if err.kind() == ErrorKind::NotFound => continue,
                 Err(err) => return Err(err),
             }
@@ -219,12 +222,14 @@ impl<R: oio::Read> oio::Read for CompleteReader<R> {
         } else {
             range.size()
         };
-        self.inner.open(range).await.map(|(rp, stream)| {
-            (
-                rp,
-                Box::new(CompleteReadStream::new(stream, size)) as Box<dyn oio::ReadStreamDyn>,
-            )
-        })
+        let (rp, stream) = self.inner.open(range).await?;
+        if let Some(metadata) = rp.metadata() {
+            ensure_file_content_length(metadata, "CompleteReader::open")?;
+        }
+        Ok((
+            rp,
+            Box::new(CompleteReadStream::new(stream, size)) as Box<dyn oio::ReadStreamDyn>,
+        ))
     }
 
     async fn read(&self, range: BytesRange) -> Result<(RpRead, Buffer)> {
@@ -234,11 +239,25 @@ impl<R: oio::Read> oio::Read for CompleteReader<R> {
             range.size()
         };
         let (rp, buffer) = self.inner.read(range).await?;
+        if let Some(metadata) = rp.metadata() {
+            ensure_file_content_length(metadata, "CompleteReader::read")?;
+        }
         check_complete(size, buffer.len() as u64)?;
         Ok((rp, buffer))
     }
 }
 
+fn ensure_file_content_length(metadata: &Metadata, operation: &'static str) -> Result<()> {
+    if metadata.is_file() && !metadata.has_content_length() {
+        return Err(Error::new(
+            ErrorKind::Unexpected,
+            "file metadata does not contain a content length",
+        )
+        .with_operation(operation));
+    }
+    Ok(())
+}
+
 pub struct CompleteReadStream<R> {
     inner: R,
     size: Option<u64>,
@@ -420,15 +439,19 @@ where
 
         // we must return `Err` before setting inner to None; otherwise,
         // we won't be able to retry `close` in `RetryLayer`.
-        let mut ret = w
+        let ret = w
             .close()
             .await
             .inspect_err(|_| self.state.transition(CompleteState::Error))?;
         self.check(ret.content_length())
             .inspect_err(|_| self.state.transition(CompleteState::Error))?;
-        if ret.content_length() == 0 {
-            ret = ret.with_content_length(self.size);
-        }
+        let ret = if ret.content_length() == 0 {
+            let mut builder = ret.into_builder();
+            builder.content_length(self.size);
+            builder.build()
+        } else {
+            ret
+        };
         self.inner = None;
         self.state.transition(CompleteState::Closed);
 
@@ -467,7 +490,7 @@ mod tests {
         }
 
         async fn close(&mut self) -> Result<Metadata> {
-            Ok(Metadata::default())
+            Ok(Metadata::builder(EntryMode::Unknown).build())
         }
 
         async fn abort(&mut self) -> Result<()> {
@@ -486,9 +509,11 @@ mod tests {
 
         async fn read(&self, _: BytesRange) -> Result<(RpRead, Buffer)> {
             Ok((
-                RpRead::new(
-                    Metadata::new(EntryMode::FILE).with_content_length(self.buffer.len() as u64),
-                ),
+                RpRead::new({
+                    let mut metadata = Metadata::builder(EntryMode::FILE);
+                    metadata.content_length(self.buffer.len() as u64);
+                    metadata.build()
+                }),
                 self.buffer.clone(),
             ))
         }
@@ -522,6 +547,25 @@ mod tests {
         assert_eq!(err.kind(), ErrorKind::Unexpected);
     }
 
+    #[test]
+    fn test_file_metadata_requires_content_length() {
+        let metadata = Metadata::builder(EntryMode::FILE).build();
+        let err = ensure_file_content_length(&metadata, "test")
+            .expect_err("file metadata without content length should fail");
+        assert_eq!(err.kind(), ErrorKind::Unexpected);
+
+        let mut metadata = Metadata::builder(EntryMode::FILE);
+        metadata.content_length(0);
+        ensure_file_content_length(&metadata.build(), "test").unwrap();
+    }
+
+    #[test]
+    fn test_directory_metadata_reports_zero_without_file_validation() {
+        let metadata = Metadata::builder(EntryMode::DIR).build();
+        ensure_file_content_length(&metadata, "test").unwrap();
+        assert_eq!(metadata.content_length(), 0);
+    }
+
     #[tokio::test]
     async fn test_writer_copy_from_error_is_terminal() {
         let mut writer = CompleteWriter::new(UnsupportedCopyWriter, false);
diff --git a/core/core/src/layers/correctness_check.rs b/core/core/src/layers/correctness_check.rs
index 574b7b4a49..fbaade527f 100644
--- a/core/core/src/layers/correctness_check.rs
+++ b/core/core/src/layers/correctness_check.rs
@@ -488,7 +488,7 @@ mod tests {
         }
 
         async fn stat(&self, _: &OperationContext, _: &str, _: OpStat) -> Result<RpStat> {
-            Ok(RpStat::new(Metadata::new(EntryMode::Unknown)))
+            Ok(RpStat::new(Metadata::builder(EntryMode::Unknown).build()))
         }
 
         fn read(&self, _ctx: &OperationContext, _: &str, _: OpRead) -> Result<Self::Reader> {
@@ -534,14 +534,22 @@ mod tests {
     impl oio::Read for MockReader {
         async fn open(&self, _: BytesRange) -> Result<(RpRead, Box<dyn oio::ReadStreamDyn>)> {
             Ok((
-                RpRead::new(Metadata::new(EntryMode::FILE).with_content_length(0)),
+                RpRead::new({
+                    let mut metadata = Metadata::builder(EntryMode::FILE);
+                    metadata.content_length(0);
+                    metadata.build()
+                }),
                 Box::new(Buffer::new()) as Box<dyn oio::ReadStreamDyn>,
             ))
         }
 
         async fn read(&self, _: BytesRange) -> Result<(RpRead, Buffer)> {
             Ok((
-                RpRead::new(Metadata::new(EntryMode::FILE).with_content_length(0)),
+                RpRead::new({
+                    let mut metadata = Metadata::builder(EntryMode::FILE);
+                    metadata.content_length(0);
+                    metadata.build()
+                }),
                 Buffer::new(),
             ))
         }
@@ -555,7 +563,7 @@ mod tests {
         }
 
         async fn close(&mut self) -> Result<Metadata> {
-            Ok(Metadata::default())
+            Ok(Metadata::builder(EntryMode::Unknown).build())
         }
 
         async fn abort(&mut self) -> Result<()> {
@@ -747,9 +755,11 @@ mod tests {
             copy_with_if_match: true,
             ..Default::default()
         });
-        let metadata = Metadata::default()
-            .with_etag("etag".to_string())
-            .with_version("version".to_string());
+        let metadata = {
+            let mut metadata = Metadata::builder(EntryMode::Unknown);
+            metadata.etag("etag").version("version");
+            metadata.build()
+        };
 
         op.write_with("path", "")
             .if_match("other-etag")
@@ -832,7 +842,11 @@ mod tests {
                 "path",
                 std::time::Duration::from_secs(60),
                 options::WriteOptions {
-                    if_not_changed: Some(Metadata::default().with_etag("etag".to_string())),
+                    if_not_changed: Some({
+                        let mut metadata = Metadata::builder(EntryMode::Unknown);
+                        metadata.etag("etag");
+                        metadata.build()
+                    }),
                     ..Default::default()
                 },
             )
diff --git a/core/core/src/layers/simulate.rs b/core/core/src/layers/simulate.rs
index a0340efe64..4e2070247e 100644
--- a/core/core/src/layers/simulate.rs
+++ b/core/core/src/layers/simulate.rs
@@ -150,7 +150,7 @@ impl SimulateService {
         let capability = self.srv.capability();
 
         if path == "/" {
-            return Ok(RpStat::new(Metadata::new(EntryMode::DIR)));
+            return Ok(RpStat::new(Metadata::builder(EntryMode::DIR).build()));
         }
 
         if path.ends_with('/') {
@@ -175,13 +175,16 @@ impl SimulateService {
                 let mut l = self.srv.list(
                     ctx,
                     path,
-                    OpList::default()
-                        .with_recursive(capability.list_with_recursive)
-                        .with_limit(1),
+                    options::ListOptions {
+                        recursive: capability.list_with_recursive,
+                        limit: Some(1),
+                        ..Default::default()
+                    }
+                    .into(),
                 )?;
 
                 return if l.next().await?.is_some() {
-                    Ok(RpStat::new(Metadata::new(EntryMode::DIR)))
+                    Ok(RpStat::new(Metadata::builder(EntryMode::DIR).build()))
                 } else {
                     Err(Error::new(
                         ErrorKind::NotFound,
@@ -263,15 +266,24 @@ impl SimulateService {
             ));
         }
 
-        let non_recursive = args.clone().with_recursive(false);
+        let mut non_recursive = args;
+        non_recursive.set_recursive(false);
 
-        let mut lister = self.simulate_list(ctx, path, OpList::new().with_recursive(true))?;
+        let mut lister = self.simulate_list(
+            ctx,
+            path,
+            options::ListOptions {
+                recursive: true,
+                ..Default::default()
+            }
+            .into(),
+        )?;
 
         while let Some(entry) = lister.next().await? {
             let entry = entry.into_entry();
             let mut entry_args = non_recursive.clone();
             if let Some(version) = entry.metadata().version() {
-                entry_args = entry_args.with_version(version);
+                entry_args.set_version(version);
             }
             deleter.delete(entry.path(), entry_args).await?;
         }
@@ -421,10 +433,11 @@ impl SimulateReader {
             return Ok(v);
         }
 
-        let mut op = OpStat::new();
-        if let Some(version) = self.args.version() {
-            op = op.with_version(version);
+        let op = options::StatOptions {
+            version: self.args.version().map(str::to_owned),
+            ..Default::default()
         }
+        .into();
 
         Ok(self
             .srv
@@ -473,7 +486,10 @@ impl ServicerFlatLister {
         Self {
             ctx,
             srv,
-            next_dir: Some(oio::Entry::new(path, Metadata::new(EntryMode::DIR))),
+            next_dir: Some(oio::Entry::new(
+                path,
+                Metadata::builder(EntryMode::DIR).build(),
+            )),
             active_lister: vec![],
         }
     }
@@ -645,7 +661,7 @@ mod tests {
             self.0 = true;
             Ok(Some(oio::Entry::new(
                 "parent/file",
-                Metadata::new(EntryMode::FILE),
+                Metadata::builder(EntryMode::FILE).build(),
             )))
         }
     }
@@ -748,7 +764,11 @@ mod tests {
         async fn open(&self, range: BytesRange) -> Result<(RpRead, Box<dyn oio::ReadStreamDyn>)> {
             *self.observed_range.lock().expect("mutex must not poison") = Some(range);
             Ok((
-                RpRead::new(Metadata::new(EntryMode::FILE).with_content_length(0)),
+                RpRead::new({
+                    let mut metadata = Metadata::builder(EntryMode::FILE);
+                    metadata.content_length(0);
+                    metadata.build()
+                }),
                 Box::new(Buffer::new()),
             ))
         }
@@ -756,7 +776,11 @@ mod tests {
         async fn read(&self, range: BytesRange) -> Result<(RpRead, Buffer)> {
             *self.observed_range.lock().expect("mutex must not poison") = Some(range);
             Ok((
-                RpRead::new(Metadata::new(EntryMode::FILE).with_content_length(0)),
+                RpRead::new({
+                    let mut metadata = Metadata::builder(EntryMode::FILE);
+                    metadata.content_length(0);
+                    metadata.build()
+                }),
                 Buffer::new(),
             ))
         }
diff --git a/core/core/src/raw/http_util/header.rs b/core/core/src/raw/http_util/header.rs
index ce2e29b8bb..4ee26d85cf 100644
--- a/core/core/src/raw/http_util/header.rs
+++ b/core/core/src/raw/http_util/header.rs
@@ -157,45 +157,45 @@ pub fn parse_into_metadata(path: &str, headers: &HeaderMap) -> Result<Metadata>
     } else {
         EntryMode::FILE
     };
-    let mut m = Metadata::new(mode);
+    let mut m = Metadata::builder(mode);
 
     if let Some(v) = parse_cache_control(headers)? {
-        m.set_cache_control(v);
+        m.cache_control(v);
     }
 
     if let Some(v) = parse_content_length(headers)? {
-        m.set_content_length(v);
+        m.content_length(v);
     }
 
     if let Some(v) = parse_content_type(headers)? {
-        m.set_content_type(v);
+        m.content_type(v);
     }
 
     if let Some(v) = parse_content_encoding(headers)? {
-        m.set_content_encoding(v);
+        m.content_encoding(v);
     }
 
     if let Some(v) = parse_content_range(headers)?.and_then(|v| v.size()) {
-        m.set_content_length(v);
+        m.content_length(v);
     }
 
     if let Some(v) = parse_etag(headers)? {
-        m.set_etag(v);
+        m.etag(v);
     }
 
     if let Some(v) = parse_content_md5(headers)? {
-        m.set_content_md5(v);
+        m.content_md5(v);
     }
 
     if let Some(v) = parse_last_modified(headers)? {
-        m.set_last_modified(v);
+        m.last_modified(v);
     }
 
     if let Some(v) = parse_content_disposition(headers)? {
-        m.set_content_disposition(v);
+        m.content_disposition(v);
     }
 
-    Ok(m)
+    Ok(m.build())
 }
 
 /// Parse prefixed headers and return a map with the prefix of each header removed.
diff --git a/core/core/src/raw/oio/copy/api.rs b/core/core/src/raw/oio/copy/api.rs
index f996bc6612..4441f5a9b2 100644
--- a/core/core/src/raw/oio/copy/api.rs
+++ b/core/core/src/raw/oio/copy/api.rs
@@ -45,7 +45,7 @@ impl Copy for () {
     }
 
     async fn close(&mut self) -> Result<Metadata> {
-        Ok(Metadata::default())
+        Ok(Metadata::builder(EntryMode::Unknown).build())
     }
 
     async fn abort(&mut self) -> Result<()> {
@@ -106,7 +106,7 @@ impl OneShotCopier {
         Self {
             factory: None,
             fut: None,
-            meta: Some(Metadata::default()),
+            meta: Some(Metadata::builder(EntryMode::Unknown).build()),
             consumed: true,
         }
     }
@@ -238,7 +238,7 @@ mod tests {
                     );
                 }
 
-                Ok(Metadata::new(EntryMode::FILE))
+                Ok(Metadata::builder(EntryMode::FILE).build())
             }
         });
 
diff --git a/core/core/src/raw/oio/copy/block_copy.rs b/core/core/src/raw/oio/copy/block_copy.rs
index cf0be68919..cc047cdf19 100644
--- a/core/core/src/raw/oio/copy/block_copy.rs
+++ b/core/core/src/raw/oio/copy/block_copy.rs
@@ -280,7 +280,10 @@ where
             self.next().await?;
         }
 
-        Ok(self.metadata.clone().unwrap_or_default())
+        Ok(self
+            .metadata
+            .clone()
+            .unwrap_or_else(|| Metadata::builder(EntryMode::Unknown).build()))
     }
 
     async fn abort(&mut self) -> Result<()> {
@@ -323,11 +326,15 @@ mod tests {
 
     impl BlockCopy for TestCopy {
         async fn source_metadata(&self) -> Result<Metadata> {
-            Ok(Metadata::default().with_content_length(4))
+            Ok({
+                let mut metadata = Metadata::builder(EntryMode::Unknown);
+                metadata.content_length(4);
+                metadata.build()
+            })
         }
 
         async fn copy_once(&self) -> Result<Metadata> {
-            Ok(Metadata::default())
+            Ok(Metadata::builder(EntryMode::Unknown).build())
         }
 
         async fn copy_block(&self, block_id: Uuid, range: BytesRange) -> Result<()> {
@@ -350,7 +357,7 @@ mod tests {
                 .into_iter()
                 .map(|block_id| state.ranges[&block_id])
                 .collect();
-            Ok(Metadata::default())
+            Ok(Metadata::builder(EntryMode::Unknown).build())
         }
 
         async fn abort_block(&self, _: Vec<Uuid>) -> Result<()> {
diff --git a/core/core/src/raw/oio/copy/multipart_copy.rs b/core/core/src/raw/oio/copy/multipart_copy.rs
index 411a68716a..d78c73cf56 100644
--- a/core/core/src/raw/oio/copy/multipart_copy.rs
+++ b/core/core/src/raw/oio/copy/multipart_copy.rs
@@ -353,7 +353,10 @@ where
             self.next().await?;
         }
 
-        Ok(self.metadata.clone().unwrap_or_default())
+        Ok(self
+            .metadata
+            .clone()
+            .unwrap_or_else(|| Metadata::builder(EntryMode::Unknown).build()))
     }
 
     async fn abort(&mut self) -> Result<()> {
@@ -398,12 +401,16 @@ mod tests {
     impl MultipartCopy for Arc<TestCopy> {
         async fn source_metadata(&self) -> Result<Metadata> {
             self.source_metadata_calls.fetch_add(1, Ordering::Relaxed);
-            Ok(Metadata::default().with_content_length(self.source_size))
+            Ok({
+                let mut metadata = Metadata::builder(EntryMode::Unknown);
+                metadata.content_length(self.source_size);
+                metadata.build()
+            })
         }
 
         async fn copy_once(&self) -> Result<Metadata> {
             self.copy_once_calls.fetch_add(1, Ordering::Relaxed);
-            Ok(Metadata::default())
+            Ok(Metadata::builder(EntryMode::Unknown).build())
         }
 
         async fn initiate_copy(&self) -> Result<String> {
@@ -426,7 +433,7 @@ mod tests {
         }
 
         async fn complete_copy(&self, _: &str, _: &[MultipartPart]) -> Result<Metadata> {
-            Ok(Metadata::default())
+            Ok(Metadata::builder(EntryMode::Unknown).build())
         }
 
         async fn abort_copy(&self, _: &str) -> Result<()> {
diff --git a/core/core/src/raw/oio/entry.rs b/core/core/src/raw/oio/entry.rs
index 350bd92ae6..2a6412f3dc 100644
--- a/core/core/src/raw/oio/entry.rs
+++ b/core/core/src/raw/oio/entry.rs
@@ -25,12 +25,19 @@ use crate::*;
 ///
 /// - `crate::Entry` is the user's public API and have less public methods.
 /// - `oio::Entry` is the raw API and doesn't expose to users.
-#[derive(Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone)]
 pub struct Entry {
-    path: String,
     meta: Metadata,
 }
 
+impl PartialEq for Entry {
+    fn eq(&self, other: &Self) -> bool {
+        self.path() == other.path() && self.meta == other.meta
+    }
+}
+
+impl Eq for Entry {}
+
 impl Entry {
     /// Create a new entry by its corresponding underlying storage.
     pub fn new(path: &str, meta: Metadata) -> Entry {
@@ -51,18 +58,26 @@ impl Entry {
             path
         );
 
-        Entry { path, meta }
+        let mut builder = meta.into_builder();
+        builder.path(path);
+        Entry {
+            meta: builder.build(),
+        }
     }
 
     /// Set path for entry.
     pub fn set_path(&mut self, path: &str) -> &mut Self {
-        self.path = path.to_string();
+        let mut builder = self.meta.clone().into_builder();
+        builder.path(path);
+        self.meta = builder.build();
         self
     }
 
     /// Get the path of entry.
     pub fn path(&self) -> &str {
-        &self.path
+        self.meta
+            .path()
+            .expect("listed entry metadata contains its path")
     }
 
     /// Set mode for entry.
@@ -71,7 +86,9 @@ impl Entry {
     ///
     /// Please use this function carefully.
     pub fn set_mode(&mut self, mode: EntryMode) -> &mut Self {
-        self.meta.set_mode(mode);
+        let mut builder = self.meta.clone().into_builder();
+        builder.mode(mode);
+        self.meta = builder.build();
         self
     }
 
@@ -84,7 +101,7 @@ impl Entry {
     ///
     /// NOTE: implement this by hand to avoid leaking raw entry to end-users.
     pub(crate) fn into_entry(self) -> crate::Entry {
-        crate::Entry::new(self.path, self.meta)
+        crate::Entry::from_metadata(self.meta)
     }
 
     /// Get metadata of entry.
@@ -92,13 +109,22 @@ impl Entry {
         &self.meta
     }
 
-    /// Get mutable metadata of entry.
-    pub fn metadata_mut(&mut self) -> &mut Metadata {
-        &mut self.meta
-    }
-
     /// Consume this entry to get its path and metadata.
     pub fn into_parts(self) -> (String, Metadata) {
-        (self.path, self.meta)
+        (self.path().to_string(), self.meta)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn entry_equality_includes_path() {
+        let metadata = Metadata::builder(EntryMode::FILE).build();
+        assert_ne!(
+            Entry::new("first", metadata.clone()),
+            Entry::new("second", metadata)
+        );
     }
 }
diff --git a/core/core/src/raw/oio/list/flat_list.rs b/core/core/src/raw/oio/list/flat_list.rs
index f7f06747bb..102dd20ec7 100644
--- a/core/core/src/raw/oio/list/flat_list.rs
+++ b/core/core/src/raw/oio/list/flat_list.rs
@@ -79,7 +79,10 @@ impl<S: Service> FlatLister<S> {
         FlatLister {
             service,
             ctx,
-            next_dir: Some(oio::Entry::new(path, Metadata::new(EntryMode::DIR))),
+            next_dir: Some(oio::Entry::new(
+                path,
+                Metadata::builder(EntryMode::DIR).build(),
+            )),
             active_lister: vec![],
         }
     }
diff --git a/core/core/src/raw/oio/write/append_write.rs b/core/core/src/raw/oio/write/append_write.rs
index 84cb034ffb..14fd467c41 100644
--- a/core/core/src/raw/oio/write/append_write.rs
+++ b/core/core/src/raw/oio/write/append_write.rs
@@ -73,7 +73,7 @@ impl<W: AppendWrite> AppendWriter<W> {
         Self {
             inner,
             offset: None,
-            meta: Metadata::default(),
+            meta: Metadata::builder(EntryMode::Unknown).build(),
         }
     }
 }
@@ -100,9 +100,9 @@ where
     }
 
     async fn close(&mut self) -> Result<Metadata> {
-        self.meta
-            .set_content_length(self.offset.unwrap_or_default());
-        Ok(self.meta.clone())
+        let mut builder = self.meta.clone().into_builder();
+        builder.content_length(self.offset.unwrap_or_default());
+        Ok(builder.build())
     }
 
     async fn abort(&mut self) -> Result<()> {
diff --git a/core/core/src/raw/oio/write/block_write.rs b/core/core/src/raw/oio/write/block_write.rs
index 394b562a78..b505d450ab 100644
--- a/core/core/src/raw/oio/write/block_write.rs
+++ b/core/core/src/raw/oio/write/block_write.rs
@@ -285,7 +285,7 @@ mod tests {
             let mut this = self.lock().unwrap();
             this.length = size;
             this.content = Some(body);
-            Ok(Metadata::default())
+            Ok(Metadata::builder(EntryMode::Unknown).build())
         }
 
         async fn write_block(&self, block_id: Uuid, size: u64, body: Buffer) -> Result<()> {
@@ -314,7 +314,7 @@ mod tests {
             }
             this.content = Some(bs.into_iter().flatten().collect());
 
-            Ok(Metadata::default())
+            Ok(Metadata::builder(EntryMode::Unknown).build())
         }
 
         async fn abort_block(&self, _: Vec<Uuid>) -> Result<()> {
diff --git a/core/core/src/raw/oio/write/multipart_write.rs b/core/core/src/raw/oio/write/multipart_write.rs
index ab9a08eddb..330b7514a6 100644
--- a/core/core/src/raw/oio/write/multipart_write.rs
+++ b/core/core/src/raw/oio/write/multipart_write.rs
@@ -429,7 +429,11 @@ mod tests {
             let mut this = self.lock().await;
             this.length = size;
             this.content = Some(body);
-            Ok(Metadata::default().with_content_length(size))
+            Ok({
+                let mut metadata = Metadata::builder(EntryMode::Unknown);
+                metadata.content_length(size);
+                metadata.build()
+            })
         }
 
         async fn initiate_part(&self) -> Result<String> {
@@ -503,7 +507,11 @@ mod tests {
             assert_eq!(upload_id, test.upload_id);
             assert_eq!(parts.len(), test.part_numbers.len());
 
-            Ok(Metadata::default().with_content_length(test.length))
+            Ok({
+                let mut metadata = Metadata::builder(EntryMode::Unknown);
+                metadata.content_length(test.length);
+                metadata.build()
+            })
         }
 
         async fn abort_part(&self, upload_id: &str) -> Result<()> {
diff --git a/core/core/src/raw/oio/write/position_write.rs b/core/core/src/raw/oio/write/position_write.rs
index 944669621c..55f102ebd0 100644
--- a/core/core/src/raw/oio/write/position_write.rs
+++ b/core/core/src/raw/oio/write/position_write.rs
@@ -227,7 +227,7 @@ mod tests {
         }
 
         async fn close(&self, _size: u64) -> Result<Metadata> {
-            Ok(Metadata::default())
+            Ok(Metadata::builder(EntryMode::Unknown).build())
         }
 
         async fn abort(&self) -> Result<()> {
diff --git a/core/core/src/raw/ops.rs b/core/core/src/raw/ops.rs
index 88dad131b7..86294ca7ec 100644
--- a/core/core/src/raw/ops.rs
+++ b/core/core/src/raw/ops.rs
@@ -20,11 +20,74 @@
 //! By using ops, users can add more context for operation.
 
 use crate::BytesRange;
+use crate::Metadata;
+use crate::UserMetadata;
 use crate::options;
 use crate::raw::*;
+use crate::types::compact::CompactValues;
+use crate::types::compact::write_bytes;
+use crate::types::metadata::user_metadata_encoded_len;
+use crate::types::metadata::write_user_metadata;
 
 use std::collections::HashMap;
 
+#[inline]
+fn string_value(values: &CompactValues, field: usize) -> Option<&str> {
+    values.get_str(field)
+}
+
+#[inline]
+fn if_not_changed_version(values: &CompactValues, field: usize) -> Option<&str> {
+    values.get(field).and_then(Metadata::compact_version)
+}
+
+#[inline]
+fn if_not_changed_etag(values: &CompactValues, field: usize) -> Option<&str> {
+    values.get(field).and_then(Metadata::compact_etag)
+}
+
+fn replace_with_if_not_changed_version<const N: usize>(
+    values: &CompactValues,
+    source_field: usize,
+    target_field: usize,
+) -> CompactValues {
+    let value = if_not_changed_version(values, source_field)
+        .expect("if_not_changed metadata contains a version");
+    values.replace::<N>(target_field, value.as_bytes())
+}
+
+fn replace_with_if_not_changed_etag<const N: usize>(
+    values: &CompactValues,
+    source_field: usize,
+    target_field: usize,
+) -> CompactValues {
+    let value = if_not_changed_etag(values, source_field)
+        .expect("if_not_changed metadata contains an ETag");
+    values.replace::<N>(target_field, value.as_bytes())
+}
+
+#[inline]
+fn encode_timestamp(value: Timestamp) -> [u8; 12] {
+    let value = value.into_inner();
+    let mut encoded = [0; 12];
+    encoded[..8].copy_from_slice(&value.as_second().to_le_bytes());
+    encoded[8..].copy_from_slice(&value.subsec_nanosecond().to_le_bytes());
+    encoded
+}
+
+#[inline]
+fn decode_timestamp(value: &[u8]) -> Timestamp {
+    let seconds = i64::from_le_bytes(value[..8].try_into().unwrap());
+    let nanoseconds = i32::from_le_bytes(value[8..].try_into().unwrap());
+    Timestamp::new(seconds, nanoseconds).expect("operation stores a previously validated timestamp")
+}
+
+fn sorted_user_metadata(value: HashMap<String, String>) -> Vec<(String, String)> {
+    let mut value: Vec<_> = value.into_iter().collect();
+    value.sort_unstable_by(|left, right| left.0.cmp(&right.0));
+    value
+}
+
 /// Arguments for `create` operation.
 ///
 /// The path must be normalized.
@@ -43,23 +106,20 @@ impl OpCreateDir {
 /// The path must be normalized.
 #[derive(Debug, Clone, Default, Eq, Hash, PartialEq)]
 pub struct OpDelete {
-    /// The version of the object to delete.
-    version: Option<String>,
-
-    /// Whether a `delete` is recursive.
-    recursive: bool,
-
-    /// The ETag that the object must match before deletion.
-    if_match: Option<String>,
-
-    /// The ETag that the object must not match before deletion.
-    if_none_match: Option<String>,
+    flags: u8,
+    values: CompactValues,
+}
 
-    /// The version that the current object must match before deletion.
-    if_version_match: Option<String>,
+const OP_DELETE_RECURSIVE: u8 = 1;
 
-    /// The version that the current object must not match before deletion.
-    if_version_not_match: Option<String>,
+#[repr(usize)]
+enum DeleteField {
+    Version,
+    IfMatch,
+    IfNoneMatch,
+    IfVersionMatch,
+    IfVersionNotMatch,
+    IfNotChanged,
 }
 
 impl OpDelete {
@@ -70,84 +130,124 @@ impl OpDelete {
 }
 
 impl OpDelete {
-    /// Set the version of the object to delete.
-    pub fn with_version(mut self, version: &str) -> Self {
-        self.version = Some(version.into());
-        self
-    }
-
-    /// Change the recursive flag of this delete operation.
-    pub fn with_recursive(mut self, recursive: bool) -> Self {
-        self.recursive = recursive;
-        self
-    }
-
-    /// Set the ETag that the object must match before deletion.
-    ///
-    /// The operation fails when the existing object's ETag does not match.
-    pub fn with_if_match(mut self, if_match: impl Into<String>) -> Self {
-        self.if_match = Some(if_match.into());
-        self
-    }
-
-    /// Set the ETag that the object must not match before deletion.
-    pub fn with_if_none_match(mut self, if_none_match: impl Into<String>) -> Self {
-        self.if_none_match = Some(if_none_match.into());
-        self
-    }
-
-    /// Set the version that the current object must match before deletion.
-    pub fn with_if_version_match(mut self, version: impl Into<String>) -> Self {
-        self.if_version_match = Some(version.into());
-        self
-    }
-
-    /// Set the version that the current object must not match before deletion.
-    pub fn with_if_version_not_match(mut self, version: impl Into<String>) -> Self {
-        self.if_version_not_match = Some(version.into());
-        self
-    }
-
     /// Return the version of the object to delete.
+    #[inline]
     pub fn version(&self) -> Option<&str> {
-        self.version.as_deref()
+        string_value(&self.values, DeleteField::Version as usize)
     }
 
     /// Whether this delete should remove objects recursively.
+    #[inline]
     pub fn recursive(&self) -> bool {
-        self.recursive
+        self.flags & OP_DELETE_RECURSIVE != 0
     }
 
     /// Return the ETag that the object must match before deletion.
+    #[inline]
     pub fn if_match(&self) -> Option<&str> {
-        self.if_match.as_deref()
+        string_value(&self.values, DeleteField::IfMatch as usize)
     }
 
     /// Return the ETag that the object must not match before deletion.
+    #[inline]
     pub fn if_none_match(&self) -> Option<&str> {
-        self.if_none_match.as_deref()
+        string_value(&self.values, DeleteField::IfNoneMatch as usize)
     }
 
     /// Return the version that the current object must match before deletion.
+    #[inline]
     pub fn if_version_match(&self) -> Option<&str> {
-        self.if_version_match.as_deref()
+        string_value(&self.values, DeleteField::IfVersionMatch as usize)
     }
 
     /// Return the version that the current object must not match before deletion.
+    #[inline]
     pub fn if_version_not_match(&self) -> Option<&str> {
-        self.if_version_not_match.as_deref()
+        string_value(&self.values, DeleteField::IfVersionNotMatch as usize)
+    }
+
+    /// Return the metadata that the object must still match before deletion.
+    pub fn if_not_changed(&self) -> Option<Metadata> {
+        self.values
+            .get(DeleteField::IfNotChanged as usize)
+            .map(Metadata::decode_compact)
+    }
+
+    #[inline]
+    pub(crate) fn has_if_not_changed(&self) -> bool {
+        self.values.contains(DeleteField::IfNotChanged as usize)
+    }
+
+    #[inline]
+    pub(crate) fn if_not_changed_version(&self) -> Option<&str> {
+        if_not_changed_version(&self.values, DeleteField::IfNotChanged as usize)
+    }
+
+    #[inline]
+    pub(crate) fn if_not_changed_etag(&self) -> Option<&str> {
+        if_not_changed_etag(&self.values, DeleteField::IfNotChanged as usize)
+    }
+
+    pub(crate) fn set_if_match_from_if_not_changed(&mut self) {
+        self.values = replace_with_if_not_changed_etag::<6>(
+            &self.values,
+            DeleteField::IfNotChanged as usize,
+            DeleteField::IfMatch as usize,
+        );
+    }
+
+    pub(crate) fn set_if_version_match_from_if_not_changed(&mut self) {
+        self.values = replace_with_if_not_changed_version::<6>(
+            &self.values,
+            DeleteField::IfNotChanged as usize,
+            DeleteField::IfVersionMatch as usize,
+        );
+    }
+
+    pub(crate) fn set_recursive(&mut self, recursive: bool) {
+        if recursive {
+            self.flags |= OP_DELETE_RECURSIVE;
+        } else {
+            self.flags &= !OP_DELETE_RECURSIVE;
+        }
+    }
+
+    pub(crate) fn set_version(&mut self, version: &str) {
+        self.values = self
+            .values
+            .replace::<6>(DeleteField::Version as usize, version.as_bytes());
     }
 }
 
 impl From<options::DeleteOptions> for OpDelete {
     fn from(value: options::DeleteOptions) -> Self {
+        let if_not_changed = value.if_not_changed.as_ref();
+        let fields = [
+            value.version.as_deref().map(str::as_bytes),
+            value.if_match.as_deref().map(str::as_bytes),
+            value.if_none_match.as_deref().map(str::as_bytes),
+            value.if_version_match.as_deref().map(str::as_bytes),
+            value.if_version_not_match.as_deref().map(str::as_bytes),
+            None,
+        ];
+        let mut lengths = fields.map(|value| value.map(<[u8]>::len));
+        lengths[DeleteField::IfNotChanged as usize] =
+            if_not_changed.map(Metadata::compact_encoded_len);
         Self {
-            version: value.version,
-            recursive: value.recursive,
-            if_match: value.if_match,
-            if_none_match: value.if_none_match,
-            if_version_match: value.if_version_match,
-            if_version_not_match: value.if_version_not_match,
+            flags: if value.recursive {
+                OP_DELETE_RECURSIVE
+            } else {
+                0
+            },
+            values: CompactValues::encode_with(&lengths, |field, output| {
+                if field == DeleteField::IfNotChanged as usize
+                    && let Some(metadata) = if_not_changed
+                {
+                    metadata.write_compact(output);
+                } else {
+                    write_bytes(output, fields[field].expect("present field has a value"));
+                }
+            }),
         }
     }
 }
@@ -171,132 +271,79 @@ pub struct OpList {
     /// The maximum number of results that the service should return per request.
     ///
     /// This can be used to control the memory consumption of a list operation.
-    limit: Option<usize>,
-
-    /// The key after which the service should start listing.
-    start_after: Option<String>,
-
-    /// Whether the list operation is recursive.
-    ///
-    /// - If `false`, the operation lists only the immediate children of the given
-    ///   path.
-    /// - If `true`, the operation lists all entries whose paths start with the
-    ///   given path.
-    ///
-    /// Defaults to `false`.
-    recursive: bool,
-
-    /// Whether to return object versions.
-    ///
-    /// - If `false`, the operation does not return object versions.
-    /// - If `true`, the operation returns object versions when the service
-    ///   supports versioning.
-    ///
-    /// Defaults to `false`.
-    versions: bool,
-
-    /// Whether to return deleted objects.
-    ///
-    /// - If `false`, the operation does not return deleted objects.
-    /// - If `true`, the operation returns deleted objects when the service
-    ///   supports versioning.
-    ///
-    /// Defaults to `false`.
-    deleted: bool,
+    limit: usize,
+    flags: u8,
+    values: CompactValues,
 }
 
+const OP_LIST_HAS_LIMIT: u8 = 1;
+const OP_LIST_RECURSIVE: u8 = 1 << 1;
+const OP_LIST_VERSIONS: u8 = 1 << 2;
+const OP_LIST_DELETED: u8 = 1 << 3;
+
 impl OpList {
     /// Create a new `OpList`.
     pub fn new() -> Self {
         Self::default()
     }
 
-    /// Set the maximum number of results per request.
-    pub fn with_limit(mut self, limit: usize) -> Self {
-        self.limit = Some(limit);
-        self
-    }
-
     /// Return the maximum number of results per request.
+    #[inline]
     pub fn limit(&self) -> Option<usize> {
-        self.limit
-    }
-
-    /// Set the key after which listing should start.
-    pub fn with_start_after(mut self, start_after: &str) -> Self {
-        self.start_after = Some(start_after.into());
-        self
+        (self.flags & OP_LIST_HAS_LIMIT != 0).then_some(self.limit)
     }
 
     /// Return the key after which listing should start.
+    #[inline]
     pub fn start_after(&self) -> Option<&str> {
-        self.start_after.as_deref()
-    }
-
-    /// Set whether the list operation is recursive.
-    ///
-    /// - If `false`, the operation lists only the immediate children of the given
-    ///   path.
-    /// - If `true`, the operation lists all entries whose paths start with the
-    ///   given path.
-    ///
-    /// Defaults to `false`.
-    pub fn with_recursive(mut self, recursive: bool) -> Self {
-        self.recursive = recursive;
-        self
+        string_value(&self.values, 0)
     }
 
     /// Return whether the list operation is recursive.
+    #[inline]
     pub fn recursive(&self) -> bool {
-        self.recursive
-    }
-
-    /// Change the concurrent of this list operation.
-    ///
-    /// The default concurrent is 1.
-    #[deprecated(since = "0.53.2", note = "concurrent in list is no-op")]
-    pub fn with_concurrent(self, concurrent: usize) -> Self {
-        let _ = concurrent;
-        self
+        self.flags & OP_LIST_RECURSIVE != 0
     }
 
     /// Get the concurrent of list operation.
     #[deprecated(since = "0.53.2", note = "concurrent in list is no-op")]
+    #[inline]
     pub fn concurrent(&self) -> usize {
         0
     }
 
-    /// Set whether to return object versions.
-    pub fn with_versions(mut self, versions: bool) -> Self {
-        self.versions = versions;
-        self
-    }
-
     /// Return whether the operation includes object versions.
+    #[inline]
     pub fn versions(&self) -> bool {
-        self.versions
-    }
-
-    /// Set whether to return deleted objects.
-    pub fn with_deleted(mut self, deleted: bool) -> Self {
-        self.deleted = deleted;
-        self
+        self.flags & OP_LIST_VERSIONS != 0
     }
 
     /// Return whether the operation includes deleted objects.
+    #[inline]
     pub fn deleted(&self) -> bool {
-        self.deleted
+        self.flags & OP_LIST_DELETED != 0
     }
 }
 
 impl From<options::ListOptions> for OpList {
     fn from(value: options::ListOptions) -> Self {
+        let mut flags = 0;
+        if value.limit.is_some() {
+            flags |= OP_LIST_HAS_LIMIT;
+        }
+        if value.recursive {
+            flags |= OP_LIST_RECURSIVE;
+        }
+        if value.versions {
+            flags |= OP_LIST_VERSIONS;
+        }
+        if value.deleted {
+            flags |= OP_LIST_DELETED;
+        }
         Self {
-            limit: value.limit,
-            start_after: value.start_after,
-            recursive: value.recursive,
-            versions: value.versions,
-            deleted: value.deleted,
+            limit: value.limit.unwrap_or_default(),
+            flags,
+            values: CompactValues::encode(&[value.start_after.as_deref().map(str::as_bytes)]),
         }
     }
 }
@@ -377,17 +424,22 @@ impl From<OpDelete> for PresignOperation {
 /// Arguments for `read` operation.
 #[derive(Debug, Clone, Default)]
 pub struct OpRead {
-    if_match: Option<String>,
-    if_none_match: Option<String>,
-    if_version_match: Option<String>,
-    if_version_not_match: Option<String>,
-    if_modified_since: Option<Timestamp>,
-    if_unmodified_since: Option<Timestamp>,
-    override_content_type: Option<String>,
-    override_cache_control: Option<String>,
-    override_content_disposition: Option<String>,
-    version: Option<String>,
-    content_length_hint: Option<u64>,
+    values: CompactValues,
+}
+
+#[repr(usize)]
+enum ReadField {
+    IfMatch,
+    IfNoneMatch,
+    IfVersionMatch,
+    IfVersionNotMatch,
+    IfModifiedSince,
+    IfUnmodifiedSince,
+    OverrideContentType,
+    OverrideCacheControl,
+    OverrideContentDisposition,
+    Version,
+    ContentLengthHint,
 }
 
 impl OpRead {
@@ -396,119 +448,99 @@ impl OpRead {
         Self::default()
     }
 
-    /// Sets the content-disposition header that should be sent back by the remote read operation.
-    pub fn with_override_content_disposition(mut self, content_disposition: &str) -> Self {
-        self.override_content_disposition = Some(content_disposition.into());
-        self
-    }
-
     /// Returns the content-disposition header that should be sent back by the remote read
     /// operation.
+    #[inline]
     pub fn override_content_disposition(&self) -> Option<&str> {
-        self.override_content_disposition.as_deref()
-    }
-
-    /// Sets the cache-control header that should be sent back by the remote read operation.
-    pub fn with_override_cache_control(mut self, cache_control: &str) -> Self {
-        self.override_cache_control = Some(cache_control.into());
-        self
+        string_value(&self.values, ReadField::OverrideContentDisposition as usize)
     }
 
     /// Returns the cache-control header that should be sent back by the remote read operation.
+    #[inline]
     pub fn override_cache_control(&self) -> Option<&str> {
-        self.override_cache_control.as_deref()
-    }
-
-    /// Sets the content-type header that should be sent back by the remote read operation.
-    pub fn with_override_content_type(mut self, content_type: &str) -> Self {
-        self.override_content_type = Some(content_type.into());
-        self
+        string_value(&self.values, ReadField::OverrideCacheControl as usize)
     }
 
     /// Returns the content-type header that should be sent back by the remote read operation.
+    #[inline]
     pub fn override_content_type(&self) -> Option<&str> {
-        self.override_content_type.as_deref()
-    }
-
-    /// Set the If-Match of the option
-    pub fn with_if_match(mut self, if_match: &str) -> Self {
-        self.if_match = Some(if_match.to_string());
-        self
+        string_value(&self.values, ReadField::OverrideContentType as usize)
     }
 
     /// Get If-Match from option
+    #[inline]
     pub fn if_match(&self) -> Option<&str> {
-        self.if_match.as_deref()
-    }
-
-    /// Set the If-None-Match of the option
-    pub fn with_if_none_match(mut self, if_none_match: &str) -> Self {
-        self.if_none_match = Some(if_none_match.to_string());
-        self
+        string_value(&self.values, ReadField::IfMatch as usize)
     }
 
     /// Get If-None-Match from option
+    #[inline]
     pub fn if_none_match(&self) -> Option<&str> {
-        self.if_none_match.as_deref()
-    }
-
-    /// Set the version that the current object must match.
-    pub fn with_if_version_match(mut self, version: &str) -> Self {
-        self.if_version_match = Some(version.to_string());
-        self
+        string_value(&self.values, ReadField::IfNoneMatch as usize)
     }
 
     /// Get the version match condition.
+    #[inline]
     pub fn if_version_match(&self) -> Option<&str> {
-        self.if_version_match.as_deref()
-    }
-
-    /// Set the version that the current object must not match.
-    pub fn with_if_version_not_match(mut self, version: &str) -> Self {
-        self.if_version_not_match = Some(version.to_string());
-        self
+        string_value(&self.values, ReadField::IfVersionMatch as usize)
     }
 
     /// Get the version non-match condition.
+    #[inline]
     pub fn if_version_not_match(&self) -> Option<&str> {
-        self.if_version_not_match.as_deref()
-    }
-
-    /// Set the If-Modified-Since of the option
-    pub fn with_if_modified_since(mut self, v: Timestamp) -> Self {
-        self.if_modified_since = Some(v);
-        self
+        string_value(&self.values, ReadField::IfVersionNotMatch as usize)
     }
 
     /// Return the If-Modified-Since condition.
+    #[inline]
     pub fn if_modified_since(&self) -> Option<Timestamp> {
-        self.if_modified_since
-    }
-
-    /// Set the If-Unmodified-Since of the option
-    pub fn with_if_unmodified_since(mut self, v: Timestamp) -> Self {
-        self.if_unmodified_since = Some(v);
-        self
+        self.values
+            .get(ReadField::IfModifiedSince as usize)
+            .map(decode_timestamp)
     }
 
     /// Get If-Unmodified-Since from option
+    #[inline]
     pub fn if_unmodified_since(&self) -> Option<Timestamp> {
-        self.if_unmodified_since
-    }
-
-    /// Set the version of the option
-    pub fn with_version(mut self, version: &str) -> Self {
-        self.version = Some(version.to_string());
-        self
+        self.values
+            .get(ReadField::IfUnmodifiedSince as usize)
+            .map(decode_timestamp)
     }
 
     /// Get version from option
+    #[inline]
     pub fn version(&self) -> Option<&str> {
-        self.version.as_deref()
+        string_value(&self.values, ReadField::Version as usize)
     }
 
     pub(crate) fn content_length_hint(&self) -> Option<u64> {
-        self.content_length_hint
+        self.values
+            .get(ReadField::ContentLengthHint as usize)
+            .map(|value| u64::from_le_bytes(value.try_into().unwrap()))
+    }
+
+    fn from_read_options(value: options::ReadOptions) -> Self {
+        let if_modified_since = value.if_modified_since.map(encode_timestamp);
+        let if_unmodified_since = value.if_unmodified_since.map(encode_timestamp);
+        let content_length_hint = value.content_length_hint.map(u64::to_le_bytes);
+        Self {
+            values: CompactValues::encode(&[
+                value.if_match.as_deref().map(str::as_bytes),
+                value.if_none_match.as_deref().map(str::as_bytes),
+                value.if_version_match.as_deref().map(str::as_bytes),
+                value.if_version_not_match.as_deref().map(str::as_bytes),
+                if_modified_since.as_ref().map(|value| value.as_slice()),
+                if_unmodified_since.as_ref().map(|value| value.as_slice()),
+                value.override_content_type.as_deref().map(str::as_bytes),
+                value.override_cache_control.as_deref().map(str::as_bytes),
+                value
+                    .override_content_disposition
+                    .as_deref()
+                    .map(str::as_bytes),
+                value.version.as_deref().map(str::as_bytes),
+                content_length_hint.as_ref().map(|value| value.as_slice()),
+            ]),
+        }
     }
 }
 
@@ -592,72 +624,44 @@ impl OpReader {
 
 impl From<options::ReadOptions> for (BytesRange, OpRead, OpReader) {
     fn from(value: options::ReadOptions) -> Self {
-        (
-            value.range,
-            OpRead {
-                if_match: value.if_match,
-                if_none_match: value.if_none_match,
-                if_version_match: value.if_version_match,
-                if_version_not_match: value.if_version_not_match,
-                if_modified_since: value.if_modified_since,
-                if_unmodified_since: value.if_unmodified_since,
-                override_content_type: value.override_content_type,
-                override_cache_control: value.override_cache_control,
-                override_content_disposition: value.override_content_disposition,
-                version: value.version,
-                content_length_hint: value.content_length_hint,
-            },
-            OpReader {
-                // Ensure concurrent is at least 1
-                concurrent: value.concurrent.max(1),
-                chunk: value.chunk,
-                gap: value.gap,
-                prefetch: 0,
-            },
-        )
+        let range = value.range;
+        let reader = OpReader {
+            concurrent: value.concurrent.max(1),
+            chunk: value.chunk,
+            gap: value.gap,
+            prefetch: 0,
+        };
+        (range, OpRead::from_read_options(value), reader)
     }
 }
 
 impl From<options::ReaderOptions> for (OpRead, OpReader) {
     fn from(value: options::ReaderOptions) -> Self {
-        (
-            OpRead {
-                if_match: value.if_match,
-                if_none_match: value.if_none_match,
-                if_version_match: value.if_version_match,
-                if_version_not_match: value.if_version_not_match,
-                if_modified_since: value.if_modified_since,
-                if_unmodified_since: value.if_unmodified_since,
-                override_content_type: None,
-                override_cache_control: None,
-                override_content_disposition: None,
-                version: value.version,
-                content_length_hint: value.content_length_hint,
-            },
-            OpReader {
-                // Ensure concurrent is at least 1
-                concurrent: value.concurrent.max(1),
-                chunk: value.chunk,
-                gap: value.gap,
-                prefetch: value.prefetch,
-            },
-        )
+        let reader = OpReader {
+            concurrent: value.concurrent.max(1),
+            chunk: value.chunk,
+            gap: value.gap,
+            prefetch: value.prefetch,
+        };
+        let read = options::ReadOptions {
+            version: value.version,
+            if_match: value.if_match,
+            if_none_match: value.if_none_match,
+            if_version_match: value.if_version_match,
+            if_version_not_match: value.if_version_not_match,
+            if_modified_since: value.if_modified_since,
+            if_unmodified_since: value.if_unmodified_since,
+            content_length_hint: value.content_length_hint,
+            ..Default::default()
+        };
+        (OpRead::from_read_options(read), reader)
     }
 }
 
 /// Arguments for `stat` operation.
 #[derive(Debug, Clone, Default)]
 pub struct OpStat {
-    if_match: Option<String>,
-    if_none_match: Option<String>,
-    if_version_match: Option<String>,
-    if_version_not_match: Option<String>,
-    if_modified_since: Option<Timestamp>,
-    if_unmodified_since: Option<Timestamp>,
-    override_content_type: Option<String>,
-    override_cache_control: Option<String>,
-    override_content_disposition: Option<String>,
-    version: Option<String>,
+    values: CompactValues,
 }
 
 impl OpStat {
@@ -666,131 +670,100 @@ impl OpStat {
         Self::default()
     }
 
-    /// Set the If-Match of the option
-    pub fn with_if_match(mut self, if_match: &str) -> Self {
-        self.if_match = Some(if_match.to_string());
-        self
-    }
-
     /// Get If-Match from option
+    #[inline]
     pub fn if_match(&self) -> Option<&str> {
-        self.if_match.as_deref()
-    }
-
-    /// Set the If-None-Match of the option
-    pub fn with_if_none_match(mut self, if_none_match: &str) -> Self {
-        self.if_none_match = Some(if_none_match.to_string());
-        self
+        string_value(&self.values, ReadField::IfMatch as usize)
     }
 
     /// Get If-None-Match from option
+    #[inline]
     pub fn if_none_match(&self) -> Option<&str> {
-        self.if_none_match.as_deref()
-    }
-
-    /// Set the version that the current object must match.
-    pub fn with_if_version_match(mut self, version: &str) -> Self {
-        self.if_version_match = Some(version.to_string());
-        self
+        string_value(&self.values, ReadField::IfNoneMatch as usize)
     }
 
     /// Get the version match condition.
+    #[inline]
     pub fn if_version_match(&self) -> Option<&str> {
-        self.if_version_match.as_deref()
-    }
-
-    /// Set the version that the current object must not match.
-    pub fn with_if_version_not_match(mut self, version: &str) -> Self {
-        self.if_version_not_match = Some(version.to_string());
-        self
+        string_value(&self.values, ReadField::IfVersionMatch as usize)
     }
 
     /// Get the version non-match condition.
+    #[inline]
     pub fn if_version_not_match(&self) -> Option<&str> {
-        self.if_version_not_match.as_deref()
-    }
-
-    /// Set the If-Modified-Since of the option
-    pub fn with_if_modified_since(mut self, v: Timestamp) -> Self {
-        self.if_modified_since = Some(v);
-        self
+        string_value(&self.values, ReadField::IfVersionNotMatch as usize)
     }
 
     /// Get If-Modified-Since from option
+    #[inline]
     pub fn if_modified_since(&self) -> Option<Timestamp> {
-        self.if_modified_since
-    }
-
-    /// Set the If-Unmodified-Since of the option
-    pub fn with_if_unmodified_since(mut self, v: Timestamp) -> Self {
-        self.if_unmodified_since = Some(v);
-        self
+        self.values
+            .get(ReadField::IfModifiedSince as usize)
+            .map(decode_timestamp)
     }
 
     /// Get If-Unmodified-Since from option
+    #[inline]
     pub fn if_unmodified_since(&self) -> Option<Timestamp> {
-        self.if_unmodified_since
-    }
-
-    /// Sets the content-disposition header that should be sent back by the remote read operation.
-    pub fn with_override_content_disposition(mut self, content_disposition: &str) -> Self {
-        self.override_content_disposition = Some(content_disposition.into());
-        self
+        self.values
+            .get(ReadField::IfUnmodifiedSince as usize)
+            .map(decode_timestamp)
     }
 
     /// Returns the content-disposition header that should be sent back by the remote read
     /// operation.
+    #[inline]
     pub fn override_content_disposition(&self) -> Option<&str> {
-        self.override_content_disposition.as_deref()
-    }
-
-    /// Sets the cache-control header that should be sent back by the remote read operation.
-    pub fn with_override_cache_control(mut self, cache_control: &str) -> Self {
-        self.override_cache_control = Some(cache_control.into());
-        self
+        string_value(&self.values, ReadField::OverrideContentDisposition as usize)
     }
 
     /// Returns the cache-control header that should be sent back by the remote read operation.
+    #[inline]
     pub fn override_cache_control(&self) -> Option<&str> {
-        self.override_cache_control.as_deref()
-    }
-
-    /// Sets the content-type header that should be sent back by the remote read operation.
-    pub fn with_override_content_type(mut self, content_type: &str) -> Self {
-        self.override_content_type = Some(content_type.into());
-        self
+        string_value(&self.values, ReadField::OverrideCacheControl as usize)
     }
 
     /// Returns the content-type header that should be sent back by the remote read operation.
+    #[inline]
     pub fn override_content_type(&self) -> Option<&str> {
-        self.override_content_type.as_deref()
-    }
-
-    /// Set the version of the option
-    pub fn with_version(mut self, version: &str) -> Self {
-        self.version = Some(version.to_string());
-        self
+        string_value(&self.values, ReadField::OverrideContentType as usize)
     }
 
     /// Get version from option
+    #[inline]
     pub fn version(&self) -> Option<&str> {
-        self.version.as_deref()
+        string_value(&self.values, ReadField::Version as usize)
+    }
+
+    pub(crate) fn from_read(value: &OpRead) -> Self {
+        // `OpStat` uses the same `ReadField` layout and simply ignores the
+        // read-only content-length hint.
+        Self {
+            values: value.values.clone(),
+        }
     }
 }
 
 impl From<options::StatOptions> for OpStat {
     fn from(value: options::StatOptions) -> Self {
+        let if_modified_since = value.if_modified_since.map(encode_timestamp);
+        let if_unmodified_since = value.if_unmodified_since.map(encode_timestamp);
         Self {
-            if_match: value.if_match,
-            if_none_match: value.if_none_match,
-            if_version_match: value.if_version_match,
-            if_version_not_match: value.if_version_not_match,
-            if_modified_since: value.if_modified_since,
-            if_unmodified_since: value.if_unmodified_since,
-            override_content_type: value.override_content_type,
-            override_cache_control: value.override_cache_control,
-            override_content_disposition: value.override_content_disposition,
-            version: value.version,
+            values: CompactValues::encode(&[
+                value.if_match.as_deref().map(str::as_bytes),
+                value.if_none_match.as_deref().map(str::as_bytes),
+                value.if_version_match.as_deref().map(str::as_bytes),
+                value.if_version_not_match.as_deref().map(str::as_bytes),
+                if_modified_since.as_ref().map(|value| value.as_slice()),
+                if_unmodified_since.as_ref().map(|value| value.as_slice()),
+                value.override_content_type.as_deref().map(str::as_bytes),
+                value.override_cache_control.as_deref().map(str::as_bytes),
+                value
+                    .override_content_disposition
+                    .as_deref()
+                    .map(str::as_bytes),
+                value.version.as_deref().map(str::as_bytes),
+            ]),
         }
     }
 }
@@ -798,18 +771,26 @@ impl From<options::StatOptions> for OpStat {
 /// Arguments for `write` operation.
 #[derive(Debug, Clone, Default)]
 pub struct OpWrite {
-    append: bool,
     concurrent: usize,
-    content_type: Option<String>,
-    content_disposition: Option<String>,
-    content_encoding: Option<String>,
-    cache_control: Option<String>,
-    if_match: Option<String>,
-    if_none_match: Option<String>,
-    if_version_match: Option<String>,
-    if_version_not_match: Option<String>,
-    if_not_exists: bool,
-    user_metadata: Option<HashMap<String, String>>,
+    flags: u8,
+    values: CompactValues,
+}
+
+const OP_WRITE_APPEND: u8 = 1;
+const OP_WRITE_IF_NOT_EXISTS: u8 = 1 << 1;
+
+#[repr(usize)]
+enum WriteField {
+    ContentType,
+    ContentDisposition,
+    ContentEncoding,
+    CacheControl,
+    IfMatch,
+    IfNoneMatch,
+    IfVersionMatch,
+    IfVersionNotMatch,
+    UserMetadata,
+    IfNotChanged,
 }
 
 impl OpWrite {
@@ -823,141 +804,164 @@ impl OpWrite {
     /// Get the append from op.
     ///
     /// The append is the flag to indicate that this write operation is an append operation.
+    #[inline]
     pub fn append(&self) -> bool {
-        self.append
-    }
-
-    /// Set the append mode of op.
-    ///
-    /// If the append mode is set, the data will be appended to the end of the file.
-    ///
-    /// # Notes
-    ///
-    /// Service could return `Unsupported` if the storage does not support append.
-    pub fn with_append(mut self, append: bool) -> Self {
-        self.append = append;
-        self
+        self.flags & OP_WRITE_APPEND != 0
     }
 
     /// Get the content type from option
+    #[inline]
     pub fn content_type(&self) -> Option<&str> {
-        self.content_type.as_deref()
-    }
-
-    /// Set the content type of option
-    pub fn with_content_type(mut self, content_type: &str) -> Self {
-        self.content_type = Some(content_type.to_string());
-        self
+        string_value(&self.values, WriteField::ContentType as usize)
     }
 
     /// Get the content disposition from option
+    #[inline]
     pub fn content_disposition(&self) -> Option<&str> {
-        self.content_disposition.as_deref()
-    }
-
-    /// Set the content disposition of option
-    pub fn with_content_disposition(mut self, content_disposition: &str) -> Self {
-        self.content_disposition = Some(content_disposition.to_string());
-        self
+        string_value(&self.values, WriteField::ContentDisposition as usize)
     }
 
     /// Get the content encoding from option
+    #[inline]
     pub fn content_encoding(&self) -> Option<&str> {
-        self.content_encoding.as_deref()
-    }
-
-    /// Set the content encoding of option
-    pub fn with_content_encoding(mut self, content_encoding: &str) -> Self {
-        self.content_encoding = Some(content_encoding.to_string());
-        self
+        string_value(&self.values, WriteField::ContentEncoding as usize)
     }
 
     /// Get the cache control from option
+    #[inline]
     pub fn cache_control(&self) -> Option<&str> {
-        self.cache_control.as_deref()
-    }
-
-    /// Set the content type of option
-    pub fn with_cache_control(mut self, cache_control: &str) -> Self {
-        self.cache_control = Some(cache_control.to_string());
-        self
+        string_value(&self.values, WriteField::CacheControl as usize)
     }
 
     /// Get the concurrent.
+    #[inline]
     pub fn concurrent(&self) -> usize {
         self.concurrent
     }
 
-    /// Set the maximum concurrent write task amount.
-    pub fn with_concurrent(mut self, concurrent: usize) -> Self {
-        self.concurrent = concurrent;
-        self
+    /// Get If-Match from option
+    #[inline]
+    pub fn if_match(&self) -> Option<&str> {
+        string_value(&self.values, WriteField::IfMatch as usize)
     }
 
-    /// Set the If-Match of the option
-    pub fn with_if_match(mut self, s: &str) -> Self {
-        self.if_match = Some(s.to_string());
-        self
+    /// Get If-None-Match from option
+    #[inline]
+    pub fn if_none_match(&self) -> Option<&str> {
+        string_value(&self.values, WriteField::IfNoneMatch as usize)
     }
 
-    /// Get If-Match from option
-    pub fn if_match(&self) -> Option<&str> {
-        self.if_match.as_deref()
+    /// Get the version match condition.
+    #[inline]
+    pub fn if_version_match(&self) -> Option<&str> {
+        string_value(&self.values, WriteField::IfVersionMatch as usize)
     }
 
-    /// Set the If-None-Match of the option
-    pub fn with_if_none_match(mut self, s: &str) -> Self {
-        self.if_none_match = Some(s.to_string());
-        self
+    /// Get the version non-match condition.
+    #[inline]
+    pub fn if_version_not_match(&self) -> Option<&str> {
+        string_value(&self.values, WriteField::IfVersionNotMatch as usize)
     }
 
-    /// Get If-None-Match from option
-    pub fn if_none_match(&self) -> Option<&str> {
-        self.if_none_match.as_deref()
+    /// Get If-Not-Exist from option
+    #[inline]
+    pub fn if_not_exists(&self) -> bool {
+        self.flags & OP_WRITE_IF_NOT_EXISTS != 0
     }
 
-    /// Set the version that the current object must match.
-    pub fn with_if_version_match(mut self, version: &str) -> Self {
-        self.if_version_match = Some(version.to_string());
-        self
+    /// Get the user defined metadata from the op
+    #[inline]
+    pub fn user_metadata(&self) -> Option<UserMetadata<'_>> {
+        self.values
+            .get(WriteField::UserMetadata as usize)
+            .map(UserMetadata::new)
     }
 
-    /// Get the version match condition.
-    pub fn if_version_match(&self) -> Option<&str> {
-        self.if_version_match.as_deref()
+    /// Return the metadata that the object must still match before writing.
+    pub fn if_not_changed(&self) -> Option<Metadata> {
+        self.values
+            .get(WriteField::IfNotChanged as usize)
+            .map(Metadata::decode_compact)
     }
 
-    /// Set the version that the current object must not match.
-    pub fn with_if_version_not_match(mut self, version: &str) -> Self {
-        self.if_version_not_match = Some(version.to_string());
-        self
+    #[inline]
+    pub(crate) fn has_if_not_changed(&self) -> bool {
+        self.values.contains(WriteField::IfNotChanged as usize)
     }
 
-    /// Get the version non-match condition.
-    pub fn if_version_not_match(&self) -> Option<&str> {
-        self.if_version_not_match.as_deref()
+    #[inline]
+    pub(crate) fn if_not_changed_version(&self) -> Option<&str> {
+        if_not_changed_version(&self.values, WriteField::IfNotChanged as usize)
     }
 
-    /// Set the If-Not-Exist of the option
-    pub fn with_if_not_exists(mut self, b: bool) -> Self {
-        self.if_not_exists = b;
-        self
+    #[inline]
+    pub(crate) fn if_not_changed_etag(&self) -> Option<&str> {
+        if_not_changed_etag(&self.values, WriteField::IfNotChanged as usize)
     }
 
-    /// Get If-Not-Exist from option
-    pub fn if_not_exists(&self) -> bool {
-        self.if_not_exists
+    pub(crate) fn set_if_match_from_if_not_changed(&mut self) {
+        self.values = replace_with_if_not_changed_etag::<10>(
+            &self.values,
+            WriteField::IfNotChanged as usize,
+            WriteField::IfMatch as usize,
+        );
     }
 
-    /// Set the user defined metadata of the op
-    pub fn with_user_metadata(mut self, metadata: HashMap<String, String>) -> Self {
-        self.user_metadata = Some(metadata);
-        self
+    pub(crate) fn set_if_version_match_from_if_not_changed(&mut self) {
+        self.values = replace_with_if_not_changed_version::<10>(
+            &self.values,
+            WriteField::IfNotChanged as usize,
+            WriteField::IfVersionMatch as usize,
+        );
     }
 
-    /// Get the user defined metadata from the op
-    pub fn user_metadata(&self) -> Option<&HashMap<String, String>> {
-        self.user_metadata.as_ref()
+    fn from_options(mut value: options::WriteOptions) -> Self {
+        let user_metadata = value.user_metadata.take().map(sorted_user_metadata);
+        let if_not_changed = value.if_not_changed.as_ref();
+        let mut flags = 0;
+        if value.append {
+            flags |= OP_WRITE_APPEND;
+        }
+        if value.if_not_exists {
+            flags |= OP_WRITE_IF_NOT_EXISTS;
+        }
+        let fields = [
+            value.content_type.as_deref().map(str::as_bytes),
+            value.content_disposition.as_deref().map(str::as_bytes),
+            value.content_encoding.as_deref().map(str::as_bytes),
+            value.cache_control.as_deref().map(str::as_bytes),
+            value.if_match.as_deref().map(str::as_bytes),
+            value.if_none_match.as_deref().map(str::as_bytes),
+            value.if_version_match.as_deref().map(str::as_bytes),
+            value.if_version_not_match.as_deref().map(str::as_bytes),
+            None,
+            None,
+        ];
+        let mut lengths = fields.map(|value| value.map(<[u8]>::len));
+        lengths[WriteField::UserMetadata as usize] =
+            user_metadata.as_deref().map(user_metadata_encoded_len);
+        lengths[WriteField::IfNotChanged as usize] =
+            if_not_changed.map(Metadata::compact_encoded_len);
+        Self {
+            concurrent: value.concurrent.max(1),
+            flags,
+            values: CompactValues::encode_with(&lengths, |field, output| match field {
+                field if field == WriteField::UserMetadata as usize => {
+                    write_user_metadata(
+                        user_metadata.as_deref().expect("present field has a value"),
+                        output,
+                    );
+                }
+                field if field == WriteField::IfNotChanged as usize => {
+                    if_not_changed
+                        .expect("present field has a value")
+                        .write_compact(output);
+                }
+                _ => {
+                    write_bytes(output, fields[field].expect("present field has a value"));
+                }
+            }),
+        }
     }
 }
 
@@ -997,39 +1001,31 @@ impl OpWriter {
 
 impl From<options::WriteOptions> for (OpWrite, OpWriter) {
     fn from(value: options::WriteOptions) -> Self {
-        (
-            OpWrite {
-                append: value.append,
-                // Ensure concurrent is at least 1
-                concurrent: value.concurrent.max(1),
-                content_type: value.content_type,
-                content_disposition: value.content_disposition,
-                content_encoding: value.content_encoding,
-                cache_control: value.cache_control,
-                if_match: value.if_match,
-                if_none_match: value.if_none_match,
-                if_version_match: value.if_version_match,
-                if_version_not_match: value.if_version_not_match,
-                if_not_exists: value.if_not_exists,
-                user_metadata: value.user_metadata,
-            },
-            OpWriter { chunk: value.chunk },
-        )
+        let writer = OpWriter { chunk: value.chunk };
+        (OpWrite::from_options(value), writer)
     }
 }
 
 /// Arguments for `copy` operation.
 #[derive(Debug, Clone, Default)]
 pub struct OpCopy {
-    if_not_exists: bool,
-    if_match: Option<String>,
-    if_none_match: Option<String>,
-    if_version_match: Option<String>,
-    if_version_not_match: Option<String>,
-    source_version: Option<String>,
     concurrent: usize,
     chunk: Option<usize>,
     source_content_length_hint: Option<u64>,
+    flags: u8,
+    values: CompactValues,
+}
+
+const OP_COPY_IF_NOT_EXISTS: u8 = 1;
+
+#[repr(usize)]
+enum CopyField {
+    IfMatch,
+    IfNoneMatch,
+    IfVersionMatch,
+    IfVersionNotMatch,
+    SourceVersion,
+    IfNotChanged,
 }
 
 impl OpCopy {
@@ -1038,84 +1034,78 @@ impl OpCopy {
         Self::default()
     }
 
-    /// Set the if_not_exists flag for the operation.
-    ///
-    /// When set to true, the copy operation will only proceed if the destination
-    /// doesn't already exist.
-    pub fn with_if_not_exists(mut self, if_not_exists: bool) -> Self {
-        self.if_not_exists = if_not_exists;
-        self
-    }
-
     /// Get if_not_exists flag.
+    #[inline]
     pub fn if_not_exists(&self) -> bool {
-        self.if_not_exists
-    }
-
-    /// Set the if_match condition for the operation.
-    ///
-    /// When set, the copy operation will only proceed if the existing destination
-    /// object's ETag matches the given value.
-    pub fn with_if_match(mut self, if_match: impl Into<String>) -> Self {
-        self.if_match = Some(if_match.into());
-        self
+        self.flags & OP_COPY_IF_NOT_EXISTS != 0
     }
 
     /// Get if_match condition.
+    #[inline]
     pub fn if_match(&self) -> Option<&str> {
-        self.if_match.as_deref()
-    }
-
-    /// Set the destination ETag non-match condition.
-    pub fn with_if_none_match(mut self, if_none_match: impl Into<String>) -> Self {
-        self.if_none_match = Some(if_none_match.into());
-        self
+        string_value(&self.values, CopyField::IfMatch as usize)
     }
 
     /// Get the destination ETag non-match condition.
+    #[inline]
     pub fn if_none_match(&self) -> Option<&str> {
-        self.if_none_match.as_deref()
-    }
-
-    /// Set the current destination version match condition.
-    pub fn with_if_version_match(mut self, version: impl Into<String>) -> Self {
-        self.if_version_match = Some(version.into());
-        self
+        string_value(&self.values, CopyField::IfNoneMatch as usize)
     }
 
     /// Get the current destination version match condition.
+    #[inline]
     pub fn if_version_match(&self) -> Option<&str> {
-        self.if_version_match.as_deref()
-    }
-
-    /// Set the current destination version non-match condition.
-    pub fn with_if_version_not_match(mut self, version: impl Into<String>) -> Self {
-        self.if_version_not_match = Some(version.into());
-        self
+        string_value(&self.values, CopyField::IfVersionMatch as usize)
     }
 
     /// Get the current destination version non-match condition.
+    #[inline]
     pub fn if_version_not_match(&self) -> Option<&str> {
-        self.if_version_not_match.as_deref()
-    }
-
-    /// Set source version for the operation.
-    ///
-    /// When set, the copy operation will copy from the specified source version.
-    pub fn with_source_version(mut self, version: impl Into<String>) -> Self {
-        self.source_version = Some(version.into());
-        self
+        string_value(&self.values, CopyField::IfVersionNotMatch as usize)
     }
 
     /// Get source version from the operation.
+    #[inline]
     pub fn source_version(&self) -> Option<&str> {
-        self.source_version.as_deref()
+        string_value(&self.values, CopyField::SourceVersion as usize)
     }
 
-    /// Set the concurrent tasks for the copy operation.
-    pub fn with_concurrent(mut self, concurrent: usize) -> Self {
-        self.concurrent = concurrent.max(1);
-        self
+    /// Return the metadata that the destination must still match before copying.
+    pub fn if_not_changed(&self) -> Option<Metadata> {
+        self.values
+            .get(CopyField::IfNotChanged as usize)
+            .map(Metadata::decode_compact)
+    }
+
+    #[inline]
+    pub(crate) fn has_if_not_changed(&self) -> bool {
+        self.values.contains(CopyField::IfNotChanged as usize)
+    }
+
+    #[inline]
+    pub(crate) fn if_not_changed_version(&self) -> Option<&str> {
+        if_not_changed_version(&self.values, CopyField::IfNotChanged as usize)
+    }
+
+    #[inline]
+    pub(crate) fn if_not_changed_etag(&self) -> Option<&str> {
+        if_not_changed_etag(&self.values, CopyField::IfNotChanged as usize)
+    }
+
+    pub(crate) fn set_if_match_from_if_not_changed(&mut self) {
+        self.values = replace_with_if_not_changed_etag::<6>(
+            &self.values,
+            CopyField::IfNotChanged as usize,
+            CopyField::IfMatch as usize,
+        );
+    }
+
+    pub(crate) fn set_if_version_match_from_if_not_changed(&mut self) {
+        self.values = replace_with_if_not_changed_version::<6>(
+            &self.values,
+            CopyField::IfNotChanged as usize,
+            CopyField::IfVersionMatch as usize,
+        );
     }
 
     /// Get the concurrent tasks for the copy operation.
@@ -1123,45 +1113,57 @@ impl OpCopy {
         self.concurrent.max(1)
     }
 
-    /// Set the chunk size for the copy operation.
-    pub fn with_chunk(mut self, chunk: usize) -> Self {
-        self.chunk = Some(chunk);
-        self
-    }
-
     /// Get the chunk size for the copy operation.
     pub fn chunk(&self) -> Option<usize> {
         self.chunk
     }
 
-    /// Set source content length hint for the copy operation.
-    pub fn with_source_content_length_hint(mut self, content_length: u64) -> Self {
-        self.source_content_length_hint = Some(content_length);
-        self
-    }
-
     /// Get source content length hint from the copy operation.
     pub fn source_content_length_hint(&self) -> Option<u64> {
         self.source_content_length_hint
     }
-}
 
-impl From<options::CopyOptions> for OpCopy {
-    fn from(value: options::CopyOptions) -> Self {
-        OpCopy {
-            if_not_exists: value.if_not_exists,
-            if_match: value.if_match,
-            if_none_match: value.if_none_match,
-            if_version_match: value.if_version_match,
-            if_version_not_match: value.if_version_not_match,
-            source_version: value.source_version,
+    fn from_options(value: options::CopyOptions) -> Self {
+        let if_not_changed = value.if_not_changed.as_ref();
+        let fields = [
+            value.if_match.as_deref().map(str::as_bytes),
+            value.if_none_match.as_deref().map(str::as_bytes),
+            value.if_version_match.as_deref().map(str::as_bytes),
+            value.if_version_not_match.as_deref().map(str::as_bytes),
+            value.source_version.as_deref().map(str::as_bytes),
+            None,
+        ];
+        let mut lengths = fields.map(|value| value.map(<[u8]>::len));
+        lengths[CopyField::IfNotChanged as usize] =
+            if_not_changed.map(Metadata::compact_encoded_len);
+        Self {
             concurrent: value.concurrent.max(1),
             chunk: value.chunk,
             source_content_length_hint: value.source_content_length_hint,
+            flags: if value.if_not_exists {
+                OP_COPY_IF_NOT_EXISTS
+            } else {
+                0
+            },
+            values: CompactValues::encode_with(&lengths, |field, output| {
+                if field == CopyField::IfNotChanged as usize
+                    && let Some(metadata) = if_not_changed
+                {
+                    metadata.write_compact(output);
+                } else {
+                    write_bytes(output, fields[field].expect("present field has a value"));
+                }
+            }),
         }
     }
 }
 
+impl From<options::CopyOptions> for OpCopy {
+    fn from(value: options::CopyOptions) -> Self {
+        OpCopy::from_options(value)
+    }
+}
+
 /// Arguments for `rename` operation.
 #[derive(Debug, Clone, Default)]
 pub struct OpRename {
@@ -1210,44 +1212,224 @@ impl From<options::RenameOptions> for OpRename {
 /// Arguments for `restore` operation.
 #[derive(Debug, Clone, Default)]
 pub struct OpRestore {
-    version: Option<String>,
-    if_not_exists: bool,
+    flags: u8,
+    values: CompactValues,
 }
 
+const OP_RESTORE_IF_NOT_EXISTS: u8 = 1;
+
 impl OpRestore {
     /// Create a new `OpRestore`.
     pub fn new() -> Self {
         Self::default()
     }
 
-    /// Set the version to restore.
-    pub fn with_version(mut self, version: impl Into<String>) -> Self {
-        self.version = Some(version.into());
-        self
-    }
-
     /// Return the version to restore.
+    #[inline]
     pub fn version(&self) -> Option<&str> {
-        self.version.as_deref()
-    }
-
-    /// Set whether the restore should fail if the path currently exists.
-    pub fn with_if_not_exists(mut self, if_not_exists: bool) -> Self {
-        self.if_not_exists = if_not_exists;
-        self
+        string_value(&self.values, 0)
     }
 
     /// Return whether the restore should fail if the path currently exists.
+    #[inline]
     pub fn if_not_exists(&self) -> bool {
-        self.if_not_exists
+        self.flags & OP_RESTORE_IF_NOT_EXISTS != 0
     }
 }
 
 impl From<options::RestoreOptions> for OpRestore {
     fn from(value: options::RestoreOptions) -> Self {
         Self {
-            version: value.version,
-            if_not_exists: value.if_not_exists,
+            flags: if value.if_not_exists {
+                OP_RESTORE_IF_NOT_EXISTS
+            } else {
+                0
+            },
+            values: CompactValues::encode(&[value.version.as_deref().map(str::as_bytes)]),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::EntryMode;
+
+    fn condition_metadata() -> Metadata {
+        let mut metadata = Metadata::builder(EntryMode::FILE);
+        metadata
+            .content_length(42)
+            .etag("etag")
+            .version("version")
+            .user_metadata([("owner".to_owned(), "opendal".to_owned())]);
+        metadata.build()
+    }
+
+    #[test]
+    fn compact_operation_layouts() {
+        assert_eq!(size_of::<OpRead>(), 16);
+        assert_eq!(size_of::<OpStat>(), 16);
+        assert_eq!(size_of::<OpWrite>(), 32);
+        assert_eq!(size_of::<OpDelete>(), 24);
+        assert_eq!(size_of::<OpCopy>(), 64);
+        assert_eq!(size_of::<OpList>(), 32);
+        assert_eq!(size_of::<OpRestore>(), 24);
+    }
+
+    #[test]
+    fn read_options_roundtrip() {
+        let modified = Timestamp::new(-1, -123).unwrap();
+        let unmodified = Timestamp::new(2, 456).unwrap();
+        let options = options::ReadOptions {
+            version: Some("version".to_owned()),
+            if_match: Some("etag".to_owned()),
+            if_none_match: Some("other-etag".to_owned()),
+            if_version_match: Some("version-match".to_owned()),
+            if_version_not_match: Some("version-not-match".to_owned()),
+            if_modified_since: Some(modified),
+            if_unmodified_since: Some(unmodified),
+            content_length_hint: Some(42),
+            override_content_type: Some("text/plain".to_owned()),
+            override_cache_control: Some("no-cache".to_owned()),
+            override_content_disposition: Some("attachment".to_owned()),
+            ..Default::default()
+        };
+        let (_, args, _) = options.into();
+
+        assert_eq!(args.version(), Some("version"));
+        assert_eq!(args.if_match(), Some("etag"));
+        assert_eq!(args.if_none_match(), Some("other-etag"));
+        assert_eq!(args.if_version_match(), Some("version-match"));
+        assert_eq!(args.if_version_not_match(), Some("version-not-match"));
+        assert_eq!(args.if_modified_since(), Some(modified));
+        assert_eq!(args.if_unmodified_since(), Some(unmodified));
+        assert_eq!(args.content_length_hint(), Some(42));
+        assert_eq!(args.override_content_type(), Some("text/plain"));
+        assert_eq!(args.override_cache_control(), Some("no-cache"));
+        assert_eq!(args.override_content_disposition(), Some("attachment"));
+    }
+
+    #[test]
+    fn write_options_preserve_owned_views_and_condition() {
+        let condition = condition_metadata();
+        let (mut args, _) = options::WriteOptions {
+            append: true,
+            concurrent: 4,
+            content_type: Some("text/plain".to_owned()),
+            content_disposition: Some("attachment".to_owned()),
+            content_encoding: Some("gzip".to_owned()),
+            cache_control: Some("no-cache".to_owned()),
+            if_match: Some("etag".to_owned()),
+            if_none_match: Some("other-etag".to_owned()),
+            if_version_match: Some("version-match".to_owned()),
+            if_version_not_match: Some("version-not-match".to_owned()),
+            if_not_exists: true,
+            if_not_changed: Some(condition.clone()),
+            user_metadata: Some(HashMap::from([("owner".to_owned(), "opendal".to_owned())])),
+            ..Default::default()
+        }
+        .into();
+
+        assert!(args.append());
+        assert_eq!(args.concurrent(), 4);
+        assert_eq!(args.content_type(), Some("text/plain"));
+        assert_eq!(args.content_disposition(), Some("attachment"));
+        assert_eq!(args.content_encoding(), Some("gzip"));
+        assert_eq!(args.cache_control(), Some("no-cache"));
+        assert_eq!(args.if_match(), Some("etag"));
+        assert_eq!(args.if_none_match(), Some("other-etag"));
+        assert_eq!(args.if_version_match(), Some("version-match"));
+        assert_eq!(args.if_version_not_match(), Some("version-not-match"));
+        assert!(args.if_not_exists());
+        assert_eq!(args.if_not_changed(), Some(condition));
+        assert_eq!(args.user_metadata().unwrap().get("owner"), Some("opendal"));
+
+        let condition = args.if_not_changed().unwrap();
+        args.set_if_version_match_from_if_not_changed();
+        assert_eq!(args.if_version_match(), Some("version"));
+        assert_eq!(args.if_not_changed(), Some(condition));
+    }
+
+    #[test]
+    fn options_freeze_does_not_lower_if_not_changed() {
+        let condition = condition_metadata();
+        let (write, _) = options::WriteOptions {
+            if_not_changed: Some(condition.clone()),
+            ..Default::default()
+        }
+        .into();
+        assert_eq!(write.if_match(), None);
+        assert_eq!(write.if_version_match(), None);
+        assert_eq!(write.if_not_changed(), Some(condition.clone()));
+
+        let delete: OpDelete = options::DeleteOptions {
+            if_not_changed: Some(condition.clone()),
+            ..Default::default()
+        }
+        .into();
+        assert_eq!(delete.if_match(), None);
+        assert_eq!(delete.if_version_match(), None);
+        assert_eq!(delete.if_not_changed(), Some(condition.clone()));
+
+        let copy: OpCopy = options::CopyOptions {
+            if_not_changed: Some(condition.clone()),
+            ..Default::default()
+        }
+        .into();
+        assert_eq!(copy.if_match(), None);
+        assert_eq!(copy.if_version_match(), None);
+        assert_eq!(copy.if_not_changed(), Some(condition));
+    }
+
+    #[test]
+    fn delete_copy_list_and_restore_options_roundtrip() {
+        let condition = condition_metadata();
+        let delete: OpDelete = options::DeleteOptions {
+            version: Some("version".to_owned()),
+            recursive: true,
+            if_match: Some("etag".to_owned()),
+            if_not_changed: Some(condition.clone()),
+            ..Default::default()
+        }
+        .into();
+        assert_eq!(delete.version(), Some("version"));
+        assert!(delete.recursive());
+        assert_eq!(delete.if_match(), Some("etag"));
+        assert_eq!(delete.if_not_changed(), Some(condition.clone()));
+
+        let copy: OpCopy = options::CopyOptions {
+            if_not_exists: true,
+            if_version_match: Some("destination-version".to_owned()),
+            source_version: Some("source-version".to_owned()),
+            if_not_changed: Some(condition.clone()),
+            ..Default::default()
+        }
+        .into();
+        assert!(copy.if_not_exists());
+        assert_eq!(copy.if_version_match(), Some("destination-version"));
+        assert_eq!(copy.source_version(), Some("source-version"));
+        assert_eq!(copy.if_not_changed(), Some(condition));
+
+        let list: OpList = options::ListOptions {
+            limit: Some(100),
+            start_after: Some("marker".to_owned()),
+            recursive: true,
+            versions: true,
+            deleted: true,
+        }
+        .into();
+        assert_eq!(list.limit(), Some(100));
+        assert_eq!(list.start_after(), Some("marker"));
+        assert!(list.recursive());
+        assert!(list.versions());
+        assert!(list.deleted());
+
+        let restore: OpRestore = options::RestoreOptions {
+            version: Some("version".to_owned()),
+            if_not_exists: true,
         }
+        .into();
+        assert_eq!(restore.version(), Some("version"));
+        assert!(restore.if_not_exists());
     }
 }
diff --git a/core/core/src/services/memory/backend.rs b/core/core/src/services/memory/backend.rs
index a4abae5f1e..9f3ec1824a 100644
--- a/core/core/src/services/memory/backend.rs
+++ b/core/core/src/services/memory/backend.rs
@@ -128,7 +128,7 @@ impl Service for MemoryBackend {
         let p = build_abs_path(&self.root, path);
 
         if p == build_abs_path(&self.root, "") {
-            Ok(RpStat::new(Metadata::new(EntryMode::DIR)))
+            Ok(RpStat::new(Metadata::builder(EntryMode::DIR).build()))
         } else {
             match self.core.get(&p)? {
                 Some(value) => Ok(RpStat::new(value.metadata)),
@@ -232,7 +232,9 @@ impl oio::StreamRead for MemoryReader {
         let content = value
             .content
             .slice(range.to_content_range(value.content.len())?);
-        let metadata = Metadata::new(EntryMode::FILE).with_content_length(total_size);
+        let mut metadata = Metadata::builder(EntryMode::FILE);
+        metadata.content_length(total_size);
+        let metadata = metadata.build();
         Ok((
             RpRead::new(metadata),
             Box::new(content) as Box<dyn oio::ReadStreamDyn>,
diff --git a/core/core/src/services/memory/lister.rs b/core/core/src/services/memory/lister.rs
index 6989cefec3..040aa82959 100644
--- a/core/core/src/services/memory/lister.rs
+++ b/core/core/src/services/memory/lister.rs
@@ -48,7 +48,10 @@ impl oio::List for MemoryLister {
                 if path.is_empty() {
                     path = "/".to_string();
                 }
-                Ok(Some(oio::Entry::new(&path, Metadata::new(mode))))
+                Ok(Some(oio::Entry::new(
+                    &path,
+                    Metadata::builder(mode).build(),
+                )))
             }
             None => Ok(None),
         }
diff --git a/core/core/src/services/memory/writer.rs b/core/core/src/services/memory/writer.rs
index b7dd50d24c..a626fafe46 100644
--- a/core/core/src/services/memory/writer.rs
+++ b/core/core/src/services/memory/writer.rs
@@ -52,22 +52,24 @@ impl oio::Write for MemoryWriter {
         let buf = self.buf.take().unwrap_or_default();
         let content = buf.collect();
 
-        let mut metadata = Metadata::new(EntryMode::FILE);
-        metadata.set_content_length(content.len() as u64);
+        let mut metadata = Metadata::builder(EntryMode::FILE);
+        metadata.content_length(content.len() as u64);
 
         if let Some(v) = self.op.cache_control() {
-            metadata.set_cache_control(v);
+            metadata.cache_control(v);
         }
         if let Some(v) = self.op.content_disposition() {
-            metadata.set_content_disposition(v);
+            metadata.content_disposition(v);
         }
         if let Some(v) = self.op.content_type() {
-            metadata.set_content_type(v);
+            metadata.content_type(v);
         }
         if let Some(v) = self.op.content_encoding() {
-            metadata.set_content_encoding(v);
+            metadata.content_encoding(v);
         }
 
+        let metadata = metadata.build();
+
         let value = MemoryValue {
             metadata: metadata.clone(),
             content,
diff --git a/core/core/src/types/compact.rs b/core/core/src/types/compact.rs
new file mode 100644
index 0000000000..c73069229c
--- /dev/null
+++ b/core/core/src/types/compact.rs
@@ -0,0 +1,321 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+use std::mem::MaybeUninit;
+use std::sync::Arc;
+
+const BITMAP_SIZE: usize = size_of::<u16>();
+const OFFSET_SIZE: usize = size_of::<u16>();
+
+/// Immutable storage for a closed set of optional byte fields.
+#[derive(Clone, Debug, Default, Eq, Hash, PartialEq)]
+pub(crate) struct CompactValues(Option<Arc<[u8]>>);
+
+impl CompactValues {
+    #[inline]
+    pub(crate) fn encode<const N: usize>(fields: &[Option<&[u8]>; N]) -> Self {
+        let lengths = fields.map(|value| value.map(<[u8]>::len));
+        Self::encode_with(&lengths, |index, output| {
+            write_bytes(output, fields[index].expect("present field has a value"));
+        })
+    }
+
+    pub(crate) fn encode_with<const N: usize>(
+        lengths: &[Option<usize>; N],
+        write_field: impl FnMut(usize, &mut [MaybeUninit<u8>]),
+    ) -> Self {
+        let layout = encoded_layout(lengths);
+        let total_len = layout.2;
+        if total_len == 0 {
+            return Self(None);
+        }
+
+        let mut encoded = Arc::<[u8]>::new_uninit_slice(total_len);
+        let output = Arc::get_mut(&mut encoded).expect("new Arc has one owner");
+        write_encoded_with_layout(lengths, output, layout, write_field);
+
+        // `write_encoded` initializes every byte in the bitmap, offsets, and payload.
+        let encoded = unsafe { encoded.assume_init() };
+        Self(Some(encoded))
+    }
+
+    pub(crate) fn encoded_len<const N: usize>(lengths: &[Option<usize>; N]) -> usize {
+        encoded_layout(lengths).2
+    }
+
+    pub(crate) fn write_encoded<const N: usize>(
+        lengths: &[Option<usize>; N],
+        output: &mut [MaybeUninit<u8>],
+        write_field: impl FnMut(usize, &mut [MaybeUninit<u8>]),
+    ) {
+        write_encoded(lengths, output, write_field)
+    }
+
+    #[inline]
+    pub(crate) fn fields<const N: usize>(&self) -> [Option<&[u8]>; N] {
+        assert!(N <= u16::BITS as usize);
+
+        let mut fields = [None; N];
+        let Some(encoded) = self.0.as_deref() else {
+            return fields;
+        };
+        let present = read_present(encoded);
+        let mut value_index = 0;
+        let mut start = BITMAP_SIZE + present.count_ones() as usize * OFFSET_SIZE;
+        for (field, value) in fields.iter_mut().enumerate() {
+            if present & (1_u16 << field) == 0 {
+                continue;
+            }
+            let end = read_offset(encoded, value_index);
+            *value = Some(&encoded[start..end]);
+            start = end;
+            value_index += 1;
+        }
+        fields
+    }
+
+    #[inline]
+    pub(crate) fn get_str(&self, field: usize) -> Option<&str> {
+        self.get(field).map(|value| {
+            // String fields only enter compact storage from `str` or `String`. Blocks decoded
+            // by this module were produced by the same internal encoders.
+            unsafe { std::str::from_utf8_unchecked(value) }
+        })
+    }
+
+    #[inline]
+    pub(crate) fn contains(&self, field: usize) -> bool {
+        assert!(field < u16::BITS as usize);
+        self.0
+            .as_deref()
+            .is_some_and(|encoded| read_present(encoded) & (1_u16 << field) != 0)
+    }
+
+    pub(crate) fn replace<const N: usize>(&self, field: usize, value: &[u8]) -> Self {
+        assert!(field < N);
+        let mut fields = self.fields::<N>();
+        fields[field] = Some(value);
+        Self::encode(&fields)
+    }
+
+    #[inline]
+    pub(crate) fn get(&self, field: usize) -> Option<&[u8]> {
+        Self::get_encoded(self.0.as_deref()?, field)
+    }
+
+    #[inline]
+    pub(crate) fn get_encoded(encoded: &[u8], field: usize) -> Option<&[u8]> {
+        assert!(field < u16::BITS as usize);
+        if encoded.is_empty() {
+            return None;
+        }
+        let present = read_present(encoded);
+        let bit = 1_u16 << field;
+        if present & bit == 0 {
+            return None;
+        }
+
+        let value_count = present.count_ones() as usize;
+        let header_len = BITMAP_SIZE + value_count * OFFSET_SIZE;
+        let value_index = (present & (bit - 1)).count_ones() as usize;
+        let start = if value_index == 0 {
+            header_len
+        } else {
+            read_offset(encoded, value_index - 1)
+        };
+        let end = read_offset(encoded, value_index);
+        Some(&encoded[start..end])
+    }
+
+    #[inline]
+    pub(crate) fn as_encoded(&self) -> Option<&[u8]> {
+        self.0.as_deref()
+    }
+
+    pub(crate) fn from_encoded(encoded: &[u8]) -> Self {
+        if encoded.is_empty() {
+            Self::default()
+        } else {
+            Self(Some(Arc::from(encoded)))
+        }
+    }
+}
+
+fn encoded_layout(lengths: &[Option<usize>]) -> (u16, usize, usize) {
+    assert!(lengths.len() <= u16::BITS as usize);
+
+    let mut present = 0_u16;
+    let mut payload_len = 0_usize;
+    for (index, value) in lengths.iter().enumerate() {
+        if let Some(value) = value {
+            present |= 1 << index;
+            payload_len = payload_len
+                .checked_add(*value)
+                .expect("compact value block length overflowed");
+        }
+    }
+
+    if present == 0 {
+        return (0, 0, 0);
+    }
+
+    let value_count = present.count_ones() as usize;
+    let header_len = BITMAP_SIZE + value_count * OFFSET_SIZE;
+    let total_len = header_len
+        .checked_add(payload_len)
+        .expect("compact value block length overflowed");
+    assert!(
+        total_len <= u16::MAX as usize,
+        "compact value block exceeds 64 KiB"
+    );
+
+    (present, header_len, total_len)
+}
+
+fn write_encoded(
+    lengths: &[Option<usize>],
+    output: &mut [MaybeUninit<u8>],
+    write_field: impl FnMut(usize, &mut [MaybeUninit<u8>]),
+) {
+    let layout = encoded_layout(lengths);
+    write_encoded_with_layout(lengths, output, layout, write_field);
+}
+
+fn write_encoded_with_layout(
+    lengths: &[Option<usize>],
+    output: &mut [MaybeUninit<u8>],
+    (present, header_len, total_len): (u16, usize, usize),
+    mut write_field: impl FnMut(usize, &mut [MaybeUninit<u8>]),
+) {
+    assert_eq!(output.len(), total_len);
+    if total_len == 0 {
+        return;
+    }
+    write_slice(output, 0, &present.to_le_bytes());
+
+    let mut payload_offset = header_len;
+    let mut value_index = 0;
+    for (field, value_len) in lengths.iter().enumerate() {
+        if let Some(value_len) = value_len {
+            write_field(
+                field,
+                &mut output[payload_offset..payload_offset + value_len],
+            );
+            payload_offset += value_len;
+            let end = u16::try_from(payload_offset).expect("value block length was validated");
+            let offset = BITMAP_SIZE + value_index * OFFSET_SIZE;
+            write_slice(output, offset, &end.to_le_bytes());
+            value_index += 1;
+        }
+    }
+
+    debug_assert_eq!(payload_offset, total_len);
+}
+
+fn write_slice(output: &mut [MaybeUninit<u8>], offset: usize, value: &[u8]) {
+    write_bytes(&mut output[offset..offset + value.len()], value);
+}
+
+pub(crate) fn write_bytes(output: &mut [MaybeUninit<u8>], value: &[u8]) {
+    debug_assert_eq!(output.len(), value.len());
+    // The slices have equal lengths and cannot overlap because `output` belongs to the new
+    // compact allocation while `value` belongs to an input field.
+    unsafe {
+        std::ptr::copy_nonoverlapping(value.as_ptr(), output.as_mut_ptr().cast(), value.len());
+    }
+}
+
+#[inline]
+fn read_present(encoded: &[u8]) -> u16 {
+    u16::from_le_bytes(
+        encoded[..BITMAP_SIZE]
+            .try_into()
+            .expect("compact value block contains a bitmap"),
+    )
+}
+
+#[inline]
+fn read_offset(encoded: &[u8], index: usize) -> usize {
+    let offset = BITMAP_SIZE + index * OFFSET_SIZE;
+    u16::from_le_bytes(
+        encoded[offset..offset + OFFSET_SIZE]
+            .try_into()
+            .expect("compact value block contains a complete offset"),
+    ) as usize
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn compact_values_roundtrip() {
+        let values = CompactValues::encode(&[Some(b"first"), None, Some(b"third"), Some(b"")]);
+
+        assert_eq!(values.get(0), Some(b"first".as_slice()));
+        assert_eq!(values.get(1), None);
+        assert_eq!(values.get(2), Some(b"third".as_slice()));
+        assert_eq!(values.get(3), Some(b"".as_slice()));
+    }
+
+    #[test]
+    fn compact_values_empty_is_default() {
+        let values = CompactValues::encode(&[None, None]);
+        assert_eq!(values, CompactValues::default());
+    }
+
+    #[test]
+    fn compact_values_replace_present_field() {
+        let values = CompactValues::encode(&[Some(b"first"), None, Some(b"third")]);
+        let values = values.replace::<3>(2, b"changed");
+
+        assert_eq!(
+            values.fields::<3>(),
+            [Some(b"first".as_slice()), None, Some(b"changed".as_slice())]
+        );
+    }
+
+    #[test]
+    fn compact_values_insert_absent_field() {
+        let values = CompactValues::encode(&[Some(b"first"), None, Some(b"third")]);
+        let values = values.replace::<3>(1, b"second");
+
+        assert_eq!(
+            values.fields::<3>(),
+            [
+                Some(b"first".as_slice()),
+                Some(b"second".as_slice()),
+                Some(b"third".as_slice()),
+            ]
+        );
+    }
+
+    #[test]
+    fn compact_values_accept_maximum_block() {
+        let value = vec![0; u16::MAX as usize - BITMAP_SIZE - OFFSET_SIZE];
+        let values = CompactValues::encode(&[Some(&value)]);
+        assert_eq!(values.as_encoded().unwrap().len(), u16::MAX as usize);
+        assert_eq!(values.get(0), Some(value.as_slice()));
+    }
+
+    #[test]
+    #[should_panic(expected = "compact value block exceeds 64 KiB")]
+    fn compact_values_reject_oversized_block() {
+        let value = vec![0; u16::MAX as usize - BITMAP_SIZE - OFFSET_SIZE + 1];
+        CompactValues::encode(&[Some(&value)]);
+    }
+}
diff --git a/core/core/src/types/context/read.rs b/core/core/src/types/context/read.rs
index 66d8a649c1..35336aa300 100644
--- a/core/core/src/types/context/read.rs
+++ b/core/core/src/types/context/read.rs
@@ -122,23 +122,7 @@ impl ReadContext {
             return Ok(v);
         }
 
-        let mut op_stat = OpStat::new();
-
-        if let Some(v) = self.args().version() {
-            op_stat = op_stat.with_version(v);
-        }
-        if let Some(v) = self.args().if_match() {
-            op_stat = op_stat.with_if_match(v);
-        }
-        if let Some(v) = self.args().if_none_match() {
-            op_stat = op_stat.with_if_none_match(v);
-        }
-        if let Some(v) = self.args().if_modified_since() {
-            op_stat = op_stat.with_if_modified_since(v);
-        }
-        if let Some(v) = self.args().if_unmodified_since() {
-            op_stat = op_stat.with_if_unmodified_since(v);
-        }
+        let op_stat = OpStat::from_read(self.args());
 
         Ok(self
             .srv
diff --git a/core/core/src/types/context/write.rs b/core/core/src/types/context/write.rs
index d7de75fd21..471605291c 100644
--- a/core/core/src/types/context/write.rs
+++ b/core/core/src/types/context/write.rs
@@ -403,7 +403,7 @@ mod tests {
         }
 
         async fn close(&mut self) -> Result<Metadata> {
-            Ok(Metadata::default())
+            Ok(Metadata::builder(EntryMode::Unknown).build())
         }
 
         async fn abort(&mut self) -> Result<()> {
diff --git a/core/core/src/types/copy.rs b/core/core/src/types/copy.rs
index c10c0de69d..0f2435919c 100644
--- a/core/core/src/types/copy.rs
+++ b/core/core/src/types/copy.rs
@@ -126,7 +126,10 @@ impl Copier {
             }
         }
 
-        Ok(self.metadata.clone().unwrap_or_default())
+        Ok(self
+            .metadata
+            .clone()
+            .unwrap_or_else(|| Metadata::builder(EntryMode::Unknown).build()))
     }
 }
 
diff --git a/core/core/src/types/delete/deleter.rs b/core/core/src/types/delete/deleter.rs
index 8e6023e604..25d40b410d 100644
--- a/core/core/src/types/delete/deleter.rs
+++ b/core/core/src/types/delete/deleter.rs
@@ -103,7 +103,7 @@ impl Deleter {
     /// Delete a path.
     pub async fn delete(&mut self, input: impl IntoDeleteInput) -> Result<()> {
         let input = input.into_delete_input();
-        let mut opts = options::DeleteOptions {
+        let opts = options::DeleteOptions {
             version: input.version,
             recursive: input.recursive,
             if_match: input.if_match,
@@ -112,11 +112,12 @@ impl Deleter {
             if_version_not_match: input.if_version_not_match,
             if_not_changed: input.if_not_changed,
         };
-        if let Some(metadata) = opts.if_not_changed.take() {
+        let mut op: OpDelete = opts.into();
+        if op.has_if_not_changed() {
             if self.capability.delete_with_if_version_match
-                && let Some(version) = metadata.version()
+                && let Some(version) = op.if_not_changed_version()
             {
-                if let Some(explicit) = opts.if_version_match.as_deref() {
+                if let Some(explicit) = op.if_version_match() {
                     if explicit != version {
                         return Err(Error::new(
                             ErrorKind::ConditionNotMatch,
@@ -125,12 +126,12 @@ impl Deleter {
                         .with_operation(Operation::Delete.into_static()));
                     }
                 } else {
-                    opts.if_version_match = Some(version.to_string());
+                    op.set_if_version_match_from_if_not_changed();
                 }
             } else if self.capability.delete_with_if_match
-                && let Some(etag) = metadata.etag()
+                && let Some(etag) = op.if_not_changed_etag()
             {
-                if let Some(explicit) = opts.if_match.as_deref() {
+                if let Some(explicit) = op.if_match() {
                     if explicit != etag {
                         return Err(Error::new(
                             ErrorKind::ConditionNotMatch,
@@ -139,7 +140,7 @@ impl Deleter {
                         .with_operation(Operation::Delete.into_static()));
                     }
                 } else {
-                    opts.if_match = Some(etag.to_string());
+                    op.set_if_match_from_if_not_changed();
                 }
             } else if !self.capability.delete_with_if_version_match
                 && !self.capability.delete_with_if_match
@@ -160,8 +161,6 @@ impl Deleter {
                 .with_operation(Operation::Delete.into_static()));
             }
         }
-        let op = opts.into();
-
         self.deleter.delete(&input.path, op).await?;
         Ok(())
     }
diff --git a/core/core/src/types/delete/input.rs b/core/core/src/types/delete/input.rs
index 53c60c53f7..ed1b096ac1 100644
--- a/core/core/src/types/delete/input.rs
+++ b/core/core/src/types/delete/input.rs
@@ -188,12 +188,17 @@ impl IntoDeleteInput for Entry {
 #[cfg(test)]
 mod tests {
     use super::*;
+    use crate::options;
 
     #[test]
     fn test_op_delete_input_preserves_if_match() {
         let input = (
             "path".to_string(),
-            OpDelete::new().with_if_match("\"etag\""),
+            options::DeleteOptions {
+                if_match: Some("\"etag\"".to_owned()),
+                ..Default::default()
+            }
+            .into(),
         )
             .into_delete_input();
 
diff --git a/core/core/src/types/entry.rs b/core/core/src/types/entry.rs
index 35812aad53..1bebdcec13 100644
--- a/core/core/src/types/entry.rs
+++ b/core/core/src/types/entry.rs
@@ -23,22 +23,14 @@ use crate::*;
 /// [`Lister`] and [`crate::blocking::Lister`] return `Entry` values.
 #[derive(Clone, Debug)]
 pub struct Entry {
-    /// Path of this entry.
-    path: String,
-
     /// Metadata of this entry.
     metadata: Metadata,
 }
 
 impl Entry {
-    /// Create an entry with metadata.
-    ///
-    /// # Notes
-    ///
-    /// The only way to get an entry with associated cached metadata
-    /// is `Operator::list`.
-    pub(crate) fn new(path: String, metadata: Metadata) -> Self {
-        Self { path, metadata }
+    pub(crate) fn from_metadata(metadata: Metadata) -> Self {
+        debug_assert!(metadata.path().is_some());
+        Self { metadata }
     }
 
     /// Path of entry. Path is relative to operator's root.
@@ -48,7 +40,9 @@ impl Entry {
     /// If this entry is a dir, `path` MUST end with `/`
     /// Otherwise, `path` MUST NOT end with `/`.
     pub fn path(&self) -> &str {
-        &self.path
+        self.metadata
+            .path()
+            .expect("listed entry metadata contains its path")
     }
 
     /// Name of entry. Name is the last segment of path.
@@ -56,7 +50,7 @@ impl Entry {
     /// If this entry is a dir, `name` MUST end with `/`
     /// Otherwise, `name` MUST NOT end with `/`.
     pub fn name(&self) -> &str {
-        get_basename(&self.path)
+        get_basename(self.path())
     }
 
     /// Fetch metadata of this entry.
@@ -66,6 +60,6 @@ impl Entry {
 
     /// Consume this entry to get its path and metadata.
     pub fn into_parts(self) -> (String, Metadata) {
-        (self.path, self.metadata)
+        (self.path().to_string(), self.metadata)
     }
 }
diff --git a/core/core/src/types/metadata.rs b/core/core/src/types/metadata.rs
index 6d3e99037b..2df8c466be 100644
--- a/core/core/src/types/metadata.rs
+++ b/core/core/src/types/metadata.rs
@@ -15,96 +15,184 @@
 // specific language governing permissions and limitations
 // under the License.
 
-use crate::raw::*;
-use crate::*;
-use std::collections::HashMap;
 use std::fmt;
+use std::mem::MaybeUninit;
+use std::str;
+
+use crate::EntryMode;
+use crate::raw::Timestamp;
+use crate::types::compact::CompactValues;
+use crate::types::compact::write_bytes;
+
+const MODE_MASK: u16 = 0b11;
+const MODE_FILE: u16 = 0b01;
+const MODE_DIR: u16 = 0b10;
+const IS_CURRENT_MASK: u16 = 0b11 << 2;
+const IS_CURRENT_FALSE: u16 = 0b01 << 2;
+const IS_CURRENT_TRUE: u16 = 0b10 << 2;
+const IS_DELETED: u16 = 1 << 4;
+const HAS_CONTENT_LENGTH: u16 = 1 << 5;
+const HAS_LAST_MODIFIED: u16 = 1 << 6;
+
+const STRING_FIELD_COUNT: usize = 7;
+const VALUE_FIELD_COUNT: usize = 9;
+
+#[derive(Clone, Copy)]
+#[repr(usize)]
+enum ValueField {
+    CacheControl,
+    ContentDisposition,
+    ContentMd5,
+    ContentType,
+    ContentEncoding,
+    Etag,
+    Version,
+    UserMetadata,
+    Path,
+}
+
+#[derive(Clone, Copy, Eq, PartialEq)]
+struct MetadataHeader {
+    content_length: u64,
+    last_modified_seconds: i64,
+    last_modified_nanoseconds: u32,
+    flags: u16,
+}
+
+impl MetadataHeader {
+    fn new(mode: EntryMode) -> Self {
+        let mut header = Self {
+            content_length: 0,
+            last_modified_seconds: 0,
+            last_modified_nanoseconds: 0,
+            flags: 0,
+        };
+        header.set_mode(mode);
+        header
+    }
+
+    fn mode(&self) -> EntryMode {
+        match self.flags & MODE_MASK {
+            MODE_FILE => EntryMode::FILE,
+            MODE_DIR => EntryMode::DIR,
+            _ => EntryMode::Unknown,
+        }
+    }
+
+    fn set_mode(&mut self, mode: EntryMode) {
+        self.flags &= !MODE_MASK;
+        self.flags |= match mode {
+            EntryMode::FILE => MODE_FILE,
+            EntryMode::DIR => MODE_DIR,
+            EntryMode::Unknown => 0,
+        };
+    }
+
+    fn is_current(&self) -> Option<bool> {
+        match self.flags & IS_CURRENT_MASK {
+            IS_CURRENT_FALSE => Some(false),
+            IS_CURRENT_TRUE => Some(true),
+            _ => None,
+        }
+    }
+
+    fn set_is_current(&mut self, value: Option<bool>) {
+        self.flags &= !IS_CURRENT_MASK;
+        self.flags |= match value {
+            Some(false) => IS_CURRENT_FALSE,
+            Some(true) => IS_CURRENT_TRUE,
+            None => 0,
+        };
+    }
+
+    fn set_flag(&mut self, flag: u16, enabled: bool) {
+        if enabled {
+            self.flags |= flag;
+        } else {
+            self.flags &= !flag;
+        }
+    }
+}
 
 /// Metadata contains all the information related to a specific path.
 ///
-/// Depending on the context of the requests, the metadata for the same path may vary. For example, two
-/// versions of the same path might have different content lengths. Keep in mind that metadata is always
-/// tied to the given context and is not a global state.
-///
-/// ## File Versions
+/// Metadata is tied to the operation that produced it. The same path can have
+/// different metadata across versions or requests.
 ///
-/// In systems that support versioning, such as AWS S3, the metadata may represent a specific version
-/// of a file.
+/// ## File versions
 ///
-/// Users can access [`Metadata::version`] to retrieve the file's version, if available. They can also
-/// use [`Metadata::is_current`] and [`Metadata::is_deleted`] to determine whether the metadata
-/// corresponds to the latest version or a deleted one.
+/// In systems that support versioning, metadata can represent a specific object
+/// version. [`Metadata::version`] returns its version identifier when available.
+/// [`Metadata::is_current`] and [`Metadata::is_deleted`] describe whether that
+/// version is current or deleted.
 ///
-/// The all possible combinations of `is_current` and `is_deleted` are as follows:
+/// | `is_current` | `is_deleted` | Meaning |
+/// | --- | --- | --- |
+/// | `Some(true)` | `false` | The current object version. |
+/// | `Some(true)` | `true` | The current delete marker or soft-deleted version. |
+/// | `Some(false)` | `false` | A previous accessible version. |
+/// | `Some(false)` | `true` | A previous deleted version. |
+/// | `None` | `false` | A non-deleted object whose current-version status is unknown. |
+/// | `None` | `true` | A deleted object whose current-version status is unknown. |
 ///
-/// | `is_current`  | `is_deleted` | description                                                                                                                                                                                                                                                                                                                                                                          |
-/// |---------------|--------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
-/// | `Some(true)`  | `false`      | **The metadata's associated version is the latest, current version.** This is the normal state, indicating that this version is the most up-to-date and accessible version.                                                                                                                                                                                                          |
-/// | `Some(true)`  | `true`       | **The metadata's associated version is the latest, deleted version (Latest Delete Marker or Soft Deleted).** This is particularly important in object storage systems like S3. It signifies that this version is the **most recent delete marker**, indicating the object has been deleted. Subsequent GET requests will return 404 errors unless a specific version ID is provided. |
-/// | `Some(false)` | `false`      | **The metadata's associated version is neither the latest version nor deleted.** This indicates that this version is a previous version, still accessible by specifying its version ID.                                                                                                                                                                                              |
-/// | `Some(false)` | `true`       | **The metadata's associated version is not the latest version and is deleted.** This represents a historical version that has been marked for deletion. Users will need to specify the version ID to access it, and accessing it may be subject to specific delete marker behavior (e.g., in S3, it might not return actual data but a specific delete marker response).             |
-/// | `None`        | `false`      | **The metadata's associated file is not deleted, but its version status is either unknown or it is not the latest version.** This likely indicates that versioning is not enabled for this file, or versioning information is unavailable.                                                                                                                                           |
-/// | `None`        | `true`       | **The metadata's associated file is deleted, but its version status is either unknown or it is not the latest version.** This typically means the file was deleted without versioning enabled, or its versioning information is unavailable. This may represent an actual data deletion operation rather than an S3 delete marker.                                                   |
-#[derive(Clone, Eq, PartialEq, Default)]
+/// Metadata is an immutable owned value. Use [`Metadata::builder`] to create a
+/// value and [`Metadata::into_builder`] to create a modified value.
+#[derive(Clone)]
 pub struct Metadata {
-    mode: EntryMode,
-
-    is_current: Option<bool>,
-    is_deleted: bool,
-
-    cache_control: Option<String>,
-    content_disposition: Option<String>,
-    content_length: Option<u64>,
-    content_md5: Option<String>,
-    content_type: Option<String>,
-    content_encoding: Option<String>,
-    etag: Option<String>,
-    last_modified: Option<Timestamp>,
-    version: Option<String>,
-
-    user_metadata: Option<HashMap<String, String>>,
+    header: MetadataHeader,
+    values: CompactValues,
+}
+
+impl PartialEq for Metadata {
+    fn eq(&self, other: &Self) -> bool {
+        self.header == other.header
+            && (0..ValueField::Path as usize)
+                .all(|field| self.values.get(field) == other.values.get(field))
+    }
 }
 
+impl Eq for Metadata {}
+
 impl fmt::Debug for Metadata {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         let mut ds = f.debug_struct("Metadata");
-        ds.field("mode", &self.mode);
+        ds.field("mode", &self.mode());
 
-        if let Some(is_current) = self.is_current {
-            ds.field("is_current", &is_current);
+        if let Some(value) = self.is_current() {
+            ds.field("is_current", &value);
         }
-        if self.is_deleted {
-            ds.field("is_deleted", &self.is_deleted);
+        if self.is_deleted() {
+            ds.field("is_deleted", &true);
         }
-        if let Some(cache_control) = &self.cache_control {
-            ds.field("cache_control", cache_control);
+        if let Some(value) = self.cache_control() {
+            ds.field("cache_control", &value);
         }
-        if let Some(content_disposition) = &self.content_disposition {
-            ds.field("content_disposition", content_disposition);
+        if let Some(value) = self.content_disposition() {
+            ds.field("content_disposition", &value);
         }
-        if let Some(content_length) = self.content_length {
-            ds.field("content_length", &content_length);
+        if self.has_content_length() {
+            ds.field("content_length", &self.content_length());
         }
-        if let Some(content_md5) = &self.content_md5 {
-            ds.field("content_md5", content_md5);
+        if let Some(value) = self.content_md5() {
+            ds.field("content_md5", &value);
         }
-        if let Some(content_type) = &self.content_type {
-            ds.field("content_type", content_type);
+        if let Some(value) = self.content_type() {
+            ds.field("content_type", &value);
         }
-        if let Some(content_encoding) = &self.content_encoding {
-            ds.field("content_encoding", content_encoding);
+        if let Some(value) = self.content_encoding() {
+            ds.field("content_encoding", &value);
         }
-        if let Some(etag) = &self.etag {
-            ds.field("etag", etag);
+        if let Some(value) = self.etag() {
+            ds.field("etag", &value);
         }
-        if let Some(last_modified) = self.last_modified {
-            ds.field("last_modified", &last_modified);
+        if let Some(value) = self.last_modified() {
+            ds.field("last_modified", &value);
         }
-        if let Some(version) = &self.version {
-            ds.field("version", version);
+        if let Some(value) = self.version() {
+            ds.field("version", &value);
         }
-        if let Some(user_metadata) = &self.user_metadata {
-            ds.field("user_metadata", user_metadata);
+        if let Some(value) = self.user_metadata() {
+            ds.field("user_metadata", &value);
         }
 
         ds.finish()
@@ -112,381 +200,695 @@ impl fmt::Debug for Metadata {
 }
 
 impl Metadata {
-    /// Create a new metadata
-    pub fn new(mode: EntryMode) -> Self {
-        Self {
-            mode,
-
-            is_current: None,
-            is_deleted: false,
-
-            cache_control: None,
-            content_length: None,
-            content_md5: None,
-            content_type: None,
-            content_encoding: None,
-            last_modified: None,
-            etag: None,
-            content_disposition: None,
-            version: None,
-            user_metadata: None,
-        }
+    /// Create a builder for metadata with the given mode.
+    #[inline]
+    pub fn builder(mode: EntryMode) -> MetadataBuilder {
+        MetadataBuilder::fresh(mode)
     }
 
-    /// mode represent this entry's mode.
-    pub fn mode(&self) -> EntryMode {
-        self.mode
+    /// Consume this metadata and return a builder initialized with its values.
+    #[inline]
+    pub fn into_builder(self) -> MetadataBuilder {
+        MetadataBuilder::from_metadata(self)
     }
 
-    /// Set mode for entry.
-    pub fn set_mode(&mut self, v: EntryMode) -> &mut Self {
-        self.mode = v;
-        self
-    }
-
-    /// Set mode for entry.
-    pub fn with_mode(mut self, v: EntryMode) -> Self {
-        self.mode = v;
-        self
+    /// Return this entry's mode.
+    #[inline]
+    pub fn mode(&self) -> EntryMode {
+        self.header.mode()
     }
 
-    /// Returns `true` if this metadata is for a file.
+    /// Return `true` if this metadata is for a file.
+    #[inline]
     pub fn is_file(&self) -> bool {
-        matches!(self.mode, EntryMode::FILE)
+        self.mode().is_file()
     }
 
-    /// Returns `true` if this metadata is for a directory.
+    /// Return `true` if this metadata is for a directory.
+    #[inline]
     pub fn is_dir(&self) -> bool {
-        matches!(self.mode, EntryMode::DIR)
+        self.mode().is_dir()
     }
 
-    /// Checks whether the metadata corresponds to the most recent version of the file.
-    ///
-    /// This function is particularly useful when working with versioned objects,
-    /// such as those stored in systems like AWS S3 with versioning enabled. It helps
-    /// determine if the retrieved metadata represents the current state of the file
-    /// or an older version.
-    ///
-    /// Refer to docs in [`Metadata`] for more information about file versions.
-    ///
-    /// # Return Value
+    /// Return whether this metadata describes the current object version.
     ///
-    /// The function returns an `Option<bool>` which can have the following values:
-    ///
-    /// - `Some(true)`:  Indicates that the metadata **is** associated with the latest version of the file.
-    ///   The metadata is current and reflects the most up-to-date state.
-    /// - `Some(false)`: Indicates that the metadata **is not** associated with the latest version of the file.
-    ///   The metadata belongs to an older version, and there might be a more recent version available.
-    /// - `None`:      Indicates that the currency of the metadata **cannot be determined**. This might occur if
-    ///   versioning is not supported or enabled, or if there is insufficient information to ascertain the version status.
+    /// `None` means the service did not report whether the version is current.
+    #[inline]
     pub fn is_current(&self) -> Option<bool> {
-        self.is_current
+        self.header.is_current()
     }
 
-    /// Set the `is_current` status of this entry.
-    ///
-    /// By default, this value will be `None`. Please avoid using this API if it's unclear whether the entry is current.
-    /// Set it to `true` if it is known to be the latest; otherwise, set it to `false`.
-    pub fn set_is_current(&mut self, is_current: bool) -> &mut Self {
-        self.is_current = Some(is_current);
-        self
+    /// Return whether this metadata describes a deleted object or delete marker.
+    #[inline]
+    pub fn is_deleted(&self) -> bool {
+        self.header.flags & IS_DELETED != 0
     }
 
-    /// Set the `is_current` status of this entry.
+    /// Return this entry's Cache-Control value.
     ///
-    /// By default, this value will be `None`. Please avoid using this API if it's unclear whether the entry is current.
-    /// Set it to `true` if it is known to be the latest; otherwise, set it to `false`.
-    pub fn with_is_current(mut self, is_current: Option<bool>) -> Self {
-        self.is_current = is_current;
-        self
+    /// See [RFC 9111](https://www.rfc-editor.org/rfc/rfc9111.html).
+    #[inline]
+    pub fn cache_control(&self) -> Option<&str> {
+        self.string(ValueField::CacheControl)
     }
 
-    /// Checks if the file (or version) associated with this metadata has been deleted.
+    /// Return the full content length of this entry.
     ///
-    /// This function returns `true` if the file represented by this metadata has been marked for
-    /// deletion or has been permanently deleted.
-    /// It returns `false` otherwise, indicating that the file (or version) is still present and accessible.
-    ///
-    /// Refer to docs in [`Metadata`] for more information about file versions.
-    ///
-    /// # Returns
-    ///
-    /// `bool`: `true` if the object is considered deleted, `false` otherwise.
-    pub fn is_deleted(&self) -> bool {
-        self.is_deleted
+    /// For file metadata returned by stat, list, or read operations, this value
+    /// is the complete object size even when a read returns only a range.
+    #[inline]
+    pub fn content_length(&self) -> u64 {
+        self.header.content_length
     }
 
-    /// Set the deleted status of this entry.
-    pub fn set_is_deleted(&mut self, v: bool) -> &mut Self {
-        self.is_deleted = v;
-        self
+    /// Return whether this metadata contains an explicit content length.
+    #[inline]
+    pub(crate) fn has_content_length(&self) -> bool {
+        self.header.flags & HAS_CONTENT_LENGTH != 0
     }
 
-    /// Set the deleted status of this entry.
-    pub fn with_is_deleted(mut self, v: bool) -> Self {
-        self.is_deleted = v;
-        self
+    /// Return this entry's Content-MD5 value.
+    ///
+    /// OpenDAL returns the service-provided value and does not guarantee that it
+    /// is the MD5 digest of the content.
+    #[inline]
+    pub fn content_md5(&self) -> Option<&str> {
+        self.string(ValueField::ContentMd5)
     }
 
-    /// Cache control of this entry.
+    /// Return this entry's Content-Type value.
     ///
-    /// Cache-Control is defined by [RFC 7234](https://httpwg.org/specs/rfc7234.html#header.cache-control)
-    /// Refer to [MDN Cache-Control](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Cache-Control) for more information.
-    pub fn cache_control(&self) -> Option<&str> {
-        self.cache_control.as_deref()
+    /// See [RFC 9110](https://www.rfc-editor.org/rfc/rfc9110.html#field.content-type).
+    #[inline]
+    pub fn content_type(&self) -> Option<&str> {
+        self.string(ValueField::ContentType)
     }
 
-    /// Set cache control of this entry.
+    /// Return this entry's Content-Encoding value.
     ///
-    /// Cache-Control is defined by [RFC 7234](https://httpwg.org/specs/rfc7234.html#header.cache-control)
-    /// Refer to [MDN Cache-Control](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Cache-Control) for more information.
-    pub fn set_cache_control(&mut self, v: &str) -> &mut Self {
-        self.cache_control = Some(v.to_string());
-        self
+    /// See [RFC 9110](https://www.rfc-editor.org/rfc/rfc9110.html#field.content-encoding).
+    #[inline]
+    pub fn content_encoding(&self) -> Option<&str> {
+        self.string(ValueField::ContentEncoding)
     }
 
-    /// Set cache control of this entry.
+    /// Return this entry's Last-Modified timestamp.
     ///
-    /// Cache-Control is defined by [RFC 7234](https://httpwg.org/specs/rfc7234.html#header.cache-control)
-    /// Refer to [MDN Cache-Control](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Cache-Control) for more information.
-    pub fn with_cache_control(mut self, v: String) -> Self {
-        self.cache_control = Some(v);
-        self
+    /// See [RFC 9110](https://www.rfc-editor.org/rfc/rfc9110.html#field.last-modified).
+    #[inline]
+    pub fn last_modified(&self) -> Option<Timestamp> {
+        if self.header.flags & HAS_LAST_MODIFIED == 0 {
+            return None;
+        }
+
+        Some(
+            Timestamp::new(
+                self.header.last_modified_seconds,
+                self.header.last_modified_nanoseconds as i32,
+            )
+            .expect("metadata stores a previously validated timestamp"),
+        )
     }
 
-    /// Content length of this entry.
-    ///
-    /// `Content-Length` is defined by [RFC 7230](https://httpwg.org/specs/rfc7230.html#header.content-length)
+    /// Return this entry's service-provided ETag as-is.
     ///
-    /// Refer to [MDN Content-Length](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Length) for more information.
-    ///
-    /// For file metadata returned by stat, list, or read operations, this value
-    /// represents the full object size, even if the read operation only returns
-    /// a range of the object.
+    /// Quotes and weak-validator prefixes are part of the returned value. See
+    /// [RFC 9110](https://www.rfc-editor.org/rfc/rfc9110.html#field.etag).
+    #[inline]
+    pub fn etag(&self) -> Option<&str> {
+        self.string(ValueField::Etag)
+    }
+
+    /// Return this entry's Content-Disposition value.
     ///
-    /// # Returns
+    /// See [RFC 6266](https://www.rfc-editor.org/rfc/rfc6266.html).
+    #[inline]
+    pub fn content_disposition(&self) -> Option<&str> {
+        self.string(ValueField::ContentDisposition)
+    }
+
+    /// Return this entry's service-specific version identifier.
+    #[inline]
+    pub fn version(&self) -> Option<&str> {
+        self.string(ValueField::Version)
+    }
+
+    /// Return a borrowed view of this entry's user metadata.
     ///
-    /// Content length of this entry. It will be `0` if the content length is not set by the storage services.
-    pub fn content_length(&self) -> u64 {
-        self.content_length.unwrap_or_default()
+    /// Service-specific metadata prefixes are removed from the returned keys.
+    #[inline]
+    pub fn user_metadata(&self) -> Option<UserMetadata<'_>> {
+        self.values
+            .get(ValueField::UserMetadata as usize)
+            .map(UserMetadata::new)
     }
 
-    /// Returns `true` if this metadata contains an explicit content length.
-    pub(crate) fn has_content_length(&self) -> bool {
-        self.content_length.is_some()
+    #[inline]
+    pub(crate) fn path(&self) -> Option<&str> {
+        self.string(ValueField::Path)
     }
 
-    /// Set content length of this entry.
-    pub fn set_content_length(&mut self, v: u64) -> &mut Self {
-        self.content_length = Some(v);
-        self
+    #[inline]
+    fn string(&self, field: ValueField) -> Option<&str> {
+        self.values.get_str(field as usize)
     }
 
-    /// Set content length of this entry.
-    pub fn with_content_length(mut self, v: u64) -> Self {
-        self.content_length = Some(v);
-        self
+    #[cfg(test)]
+    pub(crate) fn encode_compact(&self) -> Vec<u8> {
+        let len = self.compact_encoded_len();
+        let mut encoded = Vec::with_capacity(len);
+        self.write_compact(&mut encoded.spare_capacity_mut()[..len]);
+        // `write_compact` initializes exactly the capacity reserved above.
+        unsafe { encoded.set_len(len) };
+        encoded
     }
 
-    /// Content MD5 of this entry.
-    ///
-    /// Content MD5 is defined by [RFC 2616](http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html).
-    /// And removed by [RFC 7231](https://www.rfc-editor.org/rfc/rfc7231).
-    ///
-    /// OpenDAL will try its best to set this value, but not guarantee this value is the md5 of content.
-    pub fn content_md5(&self) -> Option<&str> {
-        self.content_md5.as_deref()
+    pub(crate) fn compact_encoded_len(&self) -> usize {
+        if !self.values.contains(ValueField::Path as usize) {
+            return 22 + self.values.as_encoded().map_or(0, <[u8]>::len);
+        }
+        let fields = self.logical_value_fields();
+        let lengths = fields.map(|value| value.map(<[u8]>::len));
+        22 + CompactValues::encoded_len(&lengths)
     }
 
-    /// Set content MD5 of this entry.
-    pub fn set_content_md5(&mut self, v: &str) -> &mut Self {
-        self.content_md5 = Some(v.to_string());
-        self
+    pub(crate) fn write_compact(&self, output: &mut [MaybeUninit<u8>]) {
+        debug_assert_eq!(output.len(), self.compact_encoded_len());
+        write_bytes(&mut output[..8], &self.header.content_length.to_le_bytes());
+        write_bytes(
+            &mut output[8..16],
+            &self.header.last_modified_seconds.to_le_bytes(),
+        );
+        write_bytes(
+            &mut output[16..20],
+            &self.header.last_modified_nanoseconds.to_le_bytes(),
+        );
+        write_bytes(&mut output[20..22], &self.header.flags.to_le_bytes());
+        if !self.values.contains(ValueField::Path as usize) {
+            write_bytes(
+                &mut output[22..],
+                self.values.as_encoded().unwrap_or_default(),
+            );
+            return;
+        }
+        let fields = self.logical_value_fields();
+        let lengths = fields.map(|value| value.map(<[u8]>::len));
+        CompactValues::write_encoded(&lengths, &mut output[22..], |field, output| {
+            write_bytes(output, fields[field].expect("present field has a value"));
+        });
     }
 
-    /// Set content MD5 of this entry.
-    pub fn with_content_md5(mut self, v: String) -> Self {
-        self.content_md5 = Some(v);
-        self
+    fn logical_value_fields(&self) -> [Option<&[u8]>; ValueField::Path as usize] {
+        let fields = self.values.fields::<VALUE_FIELD_COUNT>();
+        std::array::from_fn(|field| fields[field])
     }
 
-    /// Content Type of this entry.
-    ///
-    /// Content Type is defined by [RFC 9110](https://httpwg.org/specs/rfc9110.html#field.content-type).
-    ///
-    /// Refer to [MDN Content-Type](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Type) for more information.
-    pub fn content_type(&self) -> Option<&str> {
-        self.content_type.as_deref()
+    pub(crate) fn decode_compact(encoded: &[u8]) -> Self {
+        assert!(encoded.len() >= 22, "encoded metadata header is incomplete");
+        Self {
+            header: MetadataHeader {
+                content_length: u64::from_le_bytes(encoded[0..8].try_into().unwrap()),
+                last_modified_seconds: i64::from_le_bytes(encoded[8..16].try_into().unwrap()),
+                last_modified_nanoseconds: u32::from_le_bytes(encoded[16..20].try_into().unwrap()),
+                flags: u16::from_le_bytes(encoded[20..22].try_into().unwrap()),
+            },
+            values: CompactValues::from_encoded(&encoded[22..]),
+        }
     }
 
-    /// Set Content Type of this entry.
-    pub fn set_content_type(&mut self, v: &str) -> &mut Self {
-        self.content_type = Some(v.to_string());
-        self
+    #[inline]
+    pub(crate) fn compact_etag(encoded: &[u8]) -> Option<&str> {
+        Self::compact_string(encoded, ValueField::Etag)
     }
 
-    /// Set Content Type of this entry.
-    pub fn with_content_type(mut self, v: String) -> Self {
-        self.content_type = Some(v);
-        self
+    #[inline]
+    pub(crate) fn compact_version(encoded: &[u8]) -> Option<&str> {
+        Self::compact_string(encoded, ValueField::Version)
     }
 
-    /// Content Encoding of this entry.
-    ///
-    /// Content Encoding is defined by [RFC 7231](https://httpwg.org/specs/rfc7231.html#header.content-encoding)
-    ///
-    /// Refer to [MDN Content-Encoding](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Encoding) for more information.
-    pub fn content_encoding(&self) -> Option<&str> {
-        self.content_encoding.as_deref()
+    #[inline]
+    fn compact_string(encoded: &[u8], field: ValueField) -> Option<&str> {
+        assert!(encoded.len() >= 22, "encoded metadata header is incomplete");
+        CompactValues::get_encoded(&encoded[22..], field as usize).map(|value| {
+            // Compact metadata encodes strings that were already validated as UTF-8.
+            unsafe { str::from_utf8_unchecked(value) }
+        })
     }
+}
 
-    /// Set Content Encoding of this entry.
-    pub fn set_content_encoding(&mut self, v: &str) -> &mut Self {
-        self.content_encoding = Some(v.to_string());
-        self
+/// Mutable construction state for [`Metadata`].
+pub struct MetadataBuilder {
+    header: MetadataHeader,
+    values: CompactValues,
+    strings: [Option<String>; STRING_FIELD_COUNT],
+    user_metadata: Option<Vec<(String, String)>>,
+    path: Option<String>,
+}
+
+impl MetadataBuilder {
+    fn fresh(mode: EntryMode) -> Self {
+        Self {
+            header: MetadataHeader::new(mode),
+            values: CompactValues::default(),
+            strings: Default::default(),
+            user_metadata: None,
+            path: None,
+        }
     }
 
-    /// Last modified of this entry.
-    ///
-    /// `Last-Modified` is defined by [RFC 7232](https://httpwg.org/specs/rfc7232.html#header.last-modified)
-    ///
-    /// Refer to [MDN Last-Modified](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Last-Modified) for more information.
-    pub fn last_modified(&self) -> Option<Timestamp> {
-        self.last_modified
+    fn from_metadata(metadata: Metadata) -> Self {
+        Self {
+            header: metadata.header,
+            values: metadata.values,
+            strings: Default::default(),
+            user_metadata: None,
+            path: None,
+        }
     }
 
-    /// Set Last modified of this entry.
-    pub fn set_last_modified(&mut self, v: Timestamp) -> &mut Self {
-        self.last_modified = Some(v);
+    /// Set the entry mode.
+    pub fn mode(&mut self, value: EntryMode) -> &mut Self {
+        self.header.set_mode(value);
         self
     }
 
-    /// Set Last modified of this entry.
-    pub fn with_last_modified(mut self, v: Timestamp) -> Self {
-        self.last_modified = Some(v);
+    /// Set whether this metadata describes the current object version.
+    pub fn is_current(&mut self, value: Option<bool>) -> &mut Self {
+        self.header.set_is_current(value);
         self
     }
 
-    /// ETag of this entry.
-    ///
-    /// `ETag` is defined by [RFC 7232](https://httpwg.org/specs/rfc7232.html#header.etag)
-    ///
-    /// Refer to [MDN ETag](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/ETag) for more information.
-    ///
-    /// OpenDAL will return this value AS-IS like the following:
-    ///
-    /// - `"33a64df551425fcc55e4d42a148795d9f25f89d4"`
-    /// - `W/"0815"`
-    ///
-    /// `"` is part of etag.
-    pub fn etag(&self) -> Option<&str> {
-        self.etag.as_deref()
+    /// Set whether this metadata describes a deleted object.
+    pub fn is_deleted(&mut self, value: bool) -> &mut Self {
+        self.header.set_flag(IS_DELETED, value);
+        self
     }
 
-    /// Set ETag of this entry.
-    pub fn set_etag(&mut self, v: &str) -> &mut Self {
-        self.etag = Some(v.to_string());
-        self
+    /// Set the Cache-Control value.
+    pub fn cache_control(&mut self, value: impl Into<String>) -> &mut Self {
+        self.set_string(ValueField::CacheControl, value.into())
     }
 
-    /// Set ETag of this entry.
-    pub fn with_etag(mut self, v: String) -> Self {
-        self.etag = Some(v);
+    /// Set the content length.
+    pub fn content_length(&mut self, value: u64) -> &mut Self {
+        self.header.content_length = value;
+        self.header.set_flag(HAS_CONTENT_LENGTH, true);
         self
     }
 
-    /// Content-Disposition of this entry
-    ///
-    /// `Content-Disposition` is defined by [RFC 2616](https://www.rfc-editor/rfcs/2616) and
-    /// clarified usage in [RFC 6266](https://www.rfc-editor/6266).
-    ///
-    /// Refer to [MDN Content-Disposition](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Disposition) for more information.
-    ///
-    /// OpenDAL will return this value AS-IS like the following:
-    ///
-    /// - "inline"
-    /// - "attachment"
-    /// - "attachment; filename=\"filename.jpg\""
-    pub fn content_disposition(&self) -> Option<&str> {
-        self.content_disposition.as_deref()
+    /// Set the Content-MD5 value.
+    pub fn content_md5(&mut self, value: impl Into<String>) -> &mut Self {
+        self.set_string(ValueField::ContentMd5, value.into())
     }
 
-    /// Set Content-Disposition of this entry
-    pub fn set_content_disposition(&mut self, v: &str) -> &mut Self {
-        self.content_disposition = Some(v.to_string());
-        self
+    /// Set the Content-Type value.
+    pub fn content_type(&mut self, value: impl Into<String>) -> &mut Self {
+        self.set_string(ValueField::ContentType, value.into())
+    }
+
+    /// Set the Content-Encoding value.
+    pub fn content_encoding(&mut self, value: impl Into<String>) -> &mut Self {
+        self.set_string(ValueField::ContentEncoding, value.into())
     }
 
-    /// Set Content-Disposition of this entry
-    pub fn with_content_disposition(mut self, v: String) -> Self {
-        self.content_disposition = Some(v);
+    /// Set the last-modified timestamp.
+    pub fn last_modified(&mut self, value: Timestamp) -> &mut Self {
+        let value = value.into_inner();
+        self.header.last_modified_seconds = value.as_second();
+        self.header.last_modified_nanoseconds = value.subsec_nanosecond() as u32;
+        self.header.set_flag(HAS_LAST_MODIFIED, true);
         self
     }
 
-    /// Retrieves the `version` of the file, if available.
-    ///
-    /// The version is typically used in systems that support object versioning, such as AWS S3.
-    ///
-    /// # Returns
+    /// Set the ETag.
+    pub fn etag(&mut self, value: impl Into<String>) -> &mut Self {
+        self.set_string(ValueField::Etag, value.into())
+    }
+
+    /// Set the Content-Disposition value.
+    pub fn content_disposition(&mut self, value: impl Into<String>) -> &mut Self {
+        self.set_string(ValueField::ContentDisposition, value.into())
+    }
+
+    /// Set the object version.
+    pub fn version(&mut self, value: impl Into<String>) -> &mut Self {
+        self.set_string(ValueField::Version, value.into())
+    }
+
+    /// Set user metadata from owned key-value pairs.
     ///
-    /// - `Some(&str)`: If the file has a version associated with it,
-    ///   this function returns `Some` containing a reference to the version ID string.
-    /// - `None`: If the file does not have a version, or if versioning is
-    ///   not supported or enabled for the underlying storage system, this function
-    ///   returns `None`.
-    pub fn version(&self) -> Option<&str> {
-        self.version.as_deref()
+    /// Duplicate keys are rejected because user metadata has map semantics.
+    pub fn user_metadata(
+        &mut self,
+        values: impl IntoIterator<Item = (String, String)>,
+    ) -> &mut Self {
+        let mut values: Vec<_> = values.into_iter().collect();
+        values.sort_unstable_by(|left, right| left.0.cmp(&right.0));
+        assert!(
+            values.windows(2).all(|pair| pair[0].0 != pair[1].0),
+            "user metadata contains duplicate keys"
+        );
+        self.user_metadata = Some(values);
+        self
     }
 
-    /// Set the version of the file
-    pub fn set_version(&mut self, v: &str) -> &mut Self {
-        self.version = Some(v.to_string());
+    /// Finish this builder as immutable metadata.
+    pub fn build(self) -> Metadata {
+        let Self {
+            header,
+            values,
+            strings,
+            user_metadata,
+            path,
+        } = self;
+        let has_value_edits =
+            strings.iter().any(Option::is_some) || user_metadata.is_some() || path.is_some();
+        if !has_value_edits {
+            return Metadata { header, values };
+        }
+        let mut fields = values.fields::<VALUE_FIELD_COUNT>();
+        for (index, value) in strings.iter().enumerate() {
+            if let Some(value) = value {
+                fields[index] = Some(value.as_bytes());
+            }
+        }
+        let user_metadata = user_metadata.as_deref();
+        if let Some(path) = path.as_deref() {
+            fields[ValueField::Path as usize] = Some(path.as_bytes());
+        }
+
+        let mut lengths = fields.map(|value| value.map(<[u8]>::len));
+        if let Some(user_metadata) = user_metadata {
+            lengths[ValueField::UserMetadata as usize] =
+                Some(user_metadata_encoded_len(user_metadata));
+        }
+
+        let values = CompactValues::encode_with(&lengths, |field, output| {
+            if field == ValueField::UserMetadata as usize
+                && let Some(user_metadata) = user_metadata
+            {
+                write_user_metadata(user_metadata, output);
+            } else {
+                write_bytes(output, fields[field].expect("present field has a value"));
+            }
+        });
+
+        Metadata { header, values }
+    }
+
+    pub(crate) fn path(&mut self, value: impl Into<String>) -> &mut Self {
+        self.path = Some(value.into());
         self
     }
 
-    /// With the version of the file.
-    pub fn with_version(mut self, v: String) -> Self {
-        self.version = Some(v);
+    fn set_string(&mut self, field: ValueField, value: String) -> &mut Self {
+        let index = field as usize;
+        debug_assert!(index < STRING_FIELD_COUNT);
+        self.strings[index] = Some(value);
         self
     }
+}
 
-    /// User defined metadata of this entry
-    ///
-    /// The prefix of the user defined metadata key(for example: in oss, it's x-oss-meta-)
-    /// is remove from the key
-    pub fn user_metadata(&self) -> Option<&HashMap<String, String>> {
-        self.user_metadata.as_ref()
+/// Borrowed user metadata stored in a [`Metadata`] value.
+#[derive(Clone, Copy)]
+pub struct UserMetadata<'a> {
+    encoded: &'a [u8],
+}
+
+impl<'a> UserMetadata<'a> {
+    #[inline]
+    pub(crate) fn new(encoded: &'a [u8]) -> Self {
+        Self { encoded }
+    }
+
+    /// Return the value associated with `key`.
+    #[inline]
+    pub fn get(&self, key: &str) -> Option<&'a str> {
+        let mut left = 0;
+        let mut right = self.len();
+        let header_len = 2 + right * 4;
+        while left < right {
+            let middle = left + (right - left) / 2;
+            let (candidate, value) = user_metadata_entry(self.encoded, middle, header_len);
+            match candidate.cmp(key) {
+                std::cmp::Ordering::Less => left = middle + 1,
+                std::cmp::Ordering::Greater => right = middle,
+                std::cmp::Ordering::Equal => return Some(value),
+            }
+        }
+        None
     }
 
-    /// With user defined metadata of this entry
-    pub fn with_user_metadata(mut self, data: HashMap<String, String>) -> Self {
-        self.user_metadata = Some(data);
-        self
+    /// Return the number of user metadata pairs.
+    #[inline]
+    pub fn len(&self) -> usize {
+        user_metadata_count(self.encoded)
+    }
+
+    /// Return `true` when no user metadata pairs are present.
+    #[inline]
+    pub fn is_empty(&self) -> bool {
+        self.len() == 0
+    }
+}
+
+impl fmt::Debug for UserMetadata<'_> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_map().entries(*self).finish()
+    }
+}
+
+impl serde::Serialize for UserMetadata<'_> {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        serializer.collect_map(*self)
     }
 }
 
+/// Iterator over borrowed user metadata pairs.
+pub struct UserMetadataIntoIter<'a> {
+    encoded: &'a [u8],
+    index: usize,
+    header_len: usize,
+}
+
+impl<'a> Iterator for UserMetadataIntoIter<'a> {
+    type Item = (&'a str, &'a str);
+
+    fn next(&mut self) -> Option<Self::Item> {
+        if 2 + self.index * 4 == self.header_len {
+            return None;
+        }
+        let entry = user_metadata_entry(self.encoded, self.index, self.header_len);
+        self.index += 1;
+        Some(entry)
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        let remaining = (self.header_len - 2) / 4 - self.index;
+        (remaining, Some(remaining))
+    }
+}
+
+impl ExactSizeIterator for UserMetadataIntoIter<'_> {}
+
+impl<'a> IntoIterator for UserMetadata<'a> {
+    type Item = (&'a str, &'a str);
+    type IntoIter = UserMetadataIntoIter<'a>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        let len = self.len();
+        UserMetadataIntoIter {
+            encoded: self.encoded,
+            index: 0,
+            header_len: 2 + len * 4,
+        }
+    }
+}
+
+impl<'a> IntoIterator for &UserMetadata<'a> {
+    type Item = (&'a str, &'a str);
+    type IntoIter = UserMetadataIntoIter<'a>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        (*self).into_iter()
+    }
+}
+
+pub(crate) fn user_metadata_encoded_len(values: &[(String, String)]) -> usize {
+    u16::try_from(values.len()).expect("user metadata contains too many pairs");
+    let header_len = size_of::<u16>() + values.len() * 2 * size_of::<u16>();
+    let payload_len: usize = values
+        .iter()
+        .map(|(key, value)| key.len() + value.len())
+        .sum();
+    let total_len = header_len
+        .checked_add(payload_len)
+        .expect("user metadata length overflowed");
+    assert!(
+        total_len <= u16::MAX as usize,
+        "user metadata exceeds 64 KiB"
+    );
+    total_len
+}
+
+pub(crate) fn write_user_metadata(values: &[(String, String)], output: &mut [MaybeUninit<u8>]) {
+    debug_assert_eq!(output.len(), user_metadata_encoded_len(values));
+    let total_len = output.len();
+    let count = u16::try_from(values.len()).expect("user metadata contains too many pairs");
+    let header_len = size_of::<u16>() + values.len() * 2 * size_of::<u16>();
+    write_bytes(&mut output[..2], &count.to_le_bytes());
+    let mut payload_offset = header_len;
+    let mut index = 0;
+    for (key, value) in values {
+        for part in [key.as_bytes(), value.as_bytes()] {
+            write_bytes(
+                &mut output[payload_offset..payload_offset + part.len()],
+                part,
+            );
+            payload_offset += part.len();
+            let end = u16::try_from(payload_offset).expect("user metadata length was validated");
+            let offset = 2 + index * 2;
+            write_bytes(&mut output[offset..offset + 2], &end.to_le_bytes());
+            index += 1;
+        }
+    }
+    debug_assert_eq!(payload_offset, total_len);
+}
+
+#[inline]
+fn user_metadata_count(encoded: &[u8]) -> usize {
+    u16::from_le_bytes(
+        encoded[..2]
+            .try_into()
+            .expect("user metadata contains its pair count"),
+    ) as usize
+}
+
+#[inline]
+fn user_metadata_entry(encoded: &[u8], index: usize, header_len: usize) -> (&str, &str) {
+    debug_assert!(index * 4 + 6 <= header_len);
+    let key_offset = index * 2;
+    let key_start = if key_offset == 0 {
+        header_len
+    } else {
+        user_metadata_offset(encoded, key_offset - 1)
+    };
+    let key_end = user_metadata_offset(encoded, key_offset);
+    let value_end = user_metadata_offset(encoded, key_offset + 1);
+    (
+        // User metadata enters this encoding from owned UTF-8 strings.
+        unsafe { str::from_utf8_unchecked(&encoded[key_start..key_end]) },
+        // User metadata enters this encoding from owned UTF-8 strings.
+        unsafe { str::from_utf8_unchecked(&encoded[key_end..value_end]) },
+    )
+}
+
+#[inline]
+fn user_metadata_offset(encoded: &[u8], index: usize) -> usize {
+    let offset = 2 + index * 2;
+    u16::from_le_bytes(
+        encoded[offset..offset + 2]
+            .try_into()
+            .expect("user metadata contains a complete offset"),
+    ) as usize
+}
+
 #[cfg(test)]
 mod tests {
+    use std::collections::HashMap;
+
     use super::*;
 
     #[test]
-    fn debug_metadata_omits_default_values() {
-        let metadata = Metadata::new(EntryMode::FILE);
+    fn metadata_layout_is_40_bytes() {
+        assert_eq!(size_of::<MetadataHeader>(), 24);
+        assert_eq!(size_of::<CompactValues>(), 16);
+        assert_eq!(size_of::<Metadata>(), 40);
+    }
 
+    #[test]
+    fn debug_metadata_omits_default_values() {
+        let metadata = Metadata::builder(EntryMode::FILE).build();
         assert_eq!(format!("{metadata:?}"), "Metadata { mode: FILE }");
     }
 
     #[test]
-    fn debug_metadata_keeps_meaningful_values() {
-        let metadata = Metadata::new(EntryMode::FILE)
-            .with_is_current(Some(false))
-            .with_is_deleted(true)
-            .with_content_length(42)
-            .with_version("v1".to_string());
+    fn metadata_roundtrip() {
+        let timestamp = Timestamp::new(-1, -123_456_789).unwrap();
+        let mut builder = Metadata::builder(EntryMode::FILE);
+        builder
+            .is_current(Some(false))
+            .is_deleted(true)
+            .content_length(42)
+            .last_modified(timestamp)
+            .version("v1")
+            .user_metadata([
+                ("owner".to_string(), "opendal".to_string()),
+                ("region".to_string(), "us-east-1".to_string()),
+            ]);
+        let metadata = builder.build();
+
+        assert_eq!(metadata.mode(), EntryMode::FILE);
+        assert_eq!(metadata.is_current(), Some(false));
+        assert!(metadata.is_deleted());
+        assert_eq!(metadata.content_length(), 42);
+        assert_eq!(metadata.last_modified(), Some(timestamp));
+        assert_eq!(metadata.version(), Some("v1"));
+        assert_eq!(
+            metadata.user_metadata().unwrap().get("owner"),
+            Some("opendal")
+        );
+        assert_eq!(
+            metadata
+                .user_metadata()
+                .unwrap()
+                .into_iter()
+                .collect::<HashMap<_, _>>()
+                .len(),
+            2
+        );
+    }
+
+    #[test]
+    fn into_builder_preserves_values_for_header_changes() {
+        let mut builder = Metadata::builder(EntryMode::FILE);
+        builder.etag("etag");
+        let metadata = builder.build();
+        let cloned = metadata.clone();
+
+        let mut builder = metadata.into_builder();
+        builder.content_length(42);
+        let changed = builder.build();
+
+        assert_eq!(cloned.content_length(), 0);
+        assert_eq!(changed.content_length(), 42);
+        assert_eq!(changed.etag(), Some("etag"));
+        assert_eq!(cloned.etag(), Some("etag"));
+    }
+
+    #[test]
+    fn empty_user_metadata_is_present() {
+        let mut builder = Metadata::builder(EntryMode::FILE);
+        builder.user_metadata([]);
+        let metadata = builder.build();
+
+        assert!(metadata.user_metadata().unwrap().is_empty());
+    }
+
+    #[test]
+    fn internal_entry_path_does_not_change_metadata_equality() {
+        let metadata = Metadata::builder(EntryMode::FILE).build();
+        let mut builder = metadata.clone().into_builder();
+        builder.path("path");
+        let metadata_with_path = builder.build();
 
+        assert_eq!(metadata, metadata_with_path);
         assert_eq!(
-            format!("{metadata:?}"),
-            "Metadata { mode: FILE, is_current: false, is_deleted: true, content_length: 42, version: \"v1\" }"
+            Metadata::decode_compact(&metadata_with_path.encode_compact()).path(),
+            None
         );
     }
 }
diff --git a/core/core/src/types/mod.rs b/core/core/src/types/mod.rs
index 64c772b0fb..98f114153a 100644
--- a/core/core/src/types/mod.rs
+++ b/core/core/src/types/mod.rs
@@ -21,6 +21,8 @@ pub use mode::EntryMode;
 mod buffer;
 pub use buffer::Buffer;
 
+pub(crate) mod compact;
+
 mod http_transport;
 pub use http_transport::HttpBody;
 pub use http_transport::HttpTransport;
@@ -29,8 +31,11 @@ pub use http_transport::HttpTransporter;
 mod entry;
 pub use entry::Entry;
 
-mod metadata;
+pub(crate) mod metadata;
 pub use metadata::Metadata;
+pub use metadata::MetadataBuilder;
+pub use metadata::UserMetadata;
+pub use metadata::UserMetadataIntoIter;
 
 mod read;
 pub use read::*;
diff --git a/core/core/src/types/operator/operator.rs b/core/core/src/types/operator/operator.rs
index c6a7dfef9c..2d0351f8f8 100644
--- a/core/core/src/types/operator/operator.rs
+++ b/core/core/src/types/operator/operator.rs
@@ -1150,13 +1150,13 @@ impl Operator {
             );
         }
 
-        let mut opts = opts;
-        if let Some(metadata) = opts.if_not_changed.take() {
+        let (mut args, opts) = opts.into();
+        if args.has_if_not_changed() {
             let capability = srv.capability();
             if capability.write_with_if_version_match
-                && let Some(version) = metadata.version()
+                && let Some(version) = args.if_not_changed_version()
             {
-                if let Some(explicit) = opts.if_version_match.as_deref() {
+                if let Some(explicit) = args.if_version_match() {
                     if explicit != version {
                         return Err(Error::new(
                             ErrorKind::ConditionNotMatch,
@@ -1165,12 +1165,12 @@ impl Operator {
                         .with_operation(Operation::Write.into_static()));
                     }
                 } else {
-                    opts.if_version_match = Some(version.to_string());
+                    args.set_if_version_match_from_if_not_changed();
                 }
             } else if capability.write_with_if_match
-                && let Some(etag) = metadata.etag()
+                && let Some(etag) = args.if_not_changed_etag()
             {
-                if let Some(explicit) = opts.if_match.as_deref() {
+                if let Some(explicit) = args.if_match() {
                     if explicit != etag {
                         return Err(Error::new(
                             ErrorKind::ConditionNotMatch,
@@ -1179,7 +1179,7 @@ impl Operator {
                         .with_operation(Operation::Write.into_static()));
                     }
                 } else {
-                    opts.if_match = Some(etag.to_string());
+                    args.set_if_match_from_if_not_changed();
                 }
             } else if !capability.write_with_if_version_match && !capability.write_with_if_match {
                 return Err(Error::new(
@@ -1198,7 +1198,6 @@ impl Operator {
                 .with_operation(Operation::Write.into_static()));
             }
         }
-        let (args, opts) = opts.into();
         let write_context = WriteContext::new(ctx, srv, path, args, opts);
         let w = Writer::new(write_context).await?;
         Ok(w)
@@ -1444,13 +1443,13 @@ impl Operator {
             );
         }
 
-        let mut opts = opts;
-        if let Some(metadata) = opts.if_not_changed.take() {
+        let mut args: OpCopy = opts.into();
+        if args.has_if_not_changed() {
             let capability = srv.capability();
             if capability.copy_with_if_version_match
-                && let Some(version) = metadata.version()
+                && let Some(version) = args.if_not_changed_version()
             {
-                if let Some(explicit) = opts.if_version_match.as_deref() {
+                if let Some(explicit) = args.if_version_match() {
                     if explicit != version {
                         return Err(Error::new(
                             ErrorKind::ConditionNotMatch,
@@ -1459,12 +1458,12 @@ impl Operator {
                         .with_operation(Operation::Copy.into_static()));
                     }
                 } else {
-                    opts.if_version_match = Some(version.to_string());
+                    args.set_if_version_match_from_if_not_changed();
                 }
             } else if capability.copy_with_if_match
-                && let Some(etag) = metadata.etag()
+                && let Some(etag) = args.if_not_changed_etag()
             {
-                if let Some(explicit) = opts.if_match.as_deref() {
+                if let Some(explicit) = args.if_match() {
                     if explicit != etag {
                         return Err(Error::new(
                             ErrorKind::ConditionNotMatch,
@@ -1473,7 +1472,7 @@ impl Operator {
                         .with_operation(Operation::Copy.into_static()));
                     }
                 } else {
-                    opts.if_match = Some(etag.to_string());
+                    args.set_if_match_from_if_not_changed();
                 }
             } else if !capability.copy_with_if_version_match && !capability.copy_with_if_match {
                 return Err(Error::new(
@@ -1492,7 +1491,6 @@ impl Operator {
                 .with_operation(Operation::Copy.into_static()));
             }
         }
-        let args = opts.into();
         std::future::ready(Copier::create(ctx, srv, &from, &to, args)).await
     }
 
@@ -2654,13 +2652,13 @@ impl Operator {
         path: String,
         (opts, expire): (options::WriteOptions, Duration),
     ) -> Result<PresignedRequest> {
-        let mut opts = opts;
-        if let Some(metadata) = opts.if_not_changed.take() {
+        let (mut op_write, _) = opts.into();
+        if op_write.has_if_not_changed() {
             let capability = srv.capability();
             if capability.write_with_if_version_match
-                && let Some(version) = metadata.version()
+                && let Some(version) = op_write.if_not_changed_version()
             {
-                if let Some(explicit) = opts.if_version_match.as_deref() {
+                if let Some(explicit) = op_write.if_version_match() {
                     if explicit != version {
                         return Err(Error::new(
                             ErrorKind::ConditionNotMatch,
@@ -2669,12 +2667,12 @@ impl Operator {
                         .with_operation(Operation::Write.into_static()));
                     }
                 } else {
-                    opts.if_version_match = Some(version.to_string());
+                    op_write.set_if_version_match_from_if_not_changed();
                 }
             } else if capability.write_with_if_match
-                && let Some(etag) = metadata.etag()
+                && let Some(etag) = op_write.if_not_changed_etag()
             {
-                if let Some(explicit) = opts.if_match.as_deref() {
+                if let Some(explicit) = op_write.if_match() {
                     if explicit != etag {
                         return Err(Error::new(
                             ErrorKind::ConditionNotMatch,
@@ -2683,7 +2681,7 @@ impl Operator {
                         .with_operation(Operation::Write.into_static()));
                     }
                 } else {
-                    opts.if_match = Some(etag.to_string());
+                    op_write.set_if_match_from_if_not_changed();
                 }
             } else if !capability.write_with_if_version_match && !capability.write_with_if_match {
                 return Err(Error::new(
@@ -2702,7 +2700,6 @@ impl Operator {
                 .with_operation(Operation::Write.into_static()));
             }
         }
-        let (op_write, _) = opts.into();
         let op = OpPresign::new(op_write, expire);
         let rp = srv.presign(&ctx, &path, op).await?;
         Ok(rp.into_presigned_request())
@@ -2815,13 +2812,13 @@ impl Operator {
         path: String,
         (opts, expire): (options::DeleteOptions, Duration),
     ) -> Result<PresignedRequest> {
-        let mut opts = opts;
-        if let Some(metadata) = opts.if_not_changed.take() {
+        let mut op_delete = OpDelete::from(opts);
+        if op_delete.has_if_not_changed() {
             let capability = srv.capability();
             if capability.delete_with_if_version_match
-                && let Some(version) = metadata.version()
+                && let Some(version) = op_delete.if_not_changed_version()
             {
-                if let Some(explicit) = opts.if_version_match.as_deref() {
+                if let Some(explicit) = op_delete.if_version_match() {
                     if explicit != version {
                         return Err(Error::new(
                             ErrorKind::ConditionNotMatch,
@@ -2830,12 +2827,12 @@ impl Operator {
                         .with_operation(Operation::Delete.into_static()));
                     }
                 } else {
-                    opts.if_version_match = Some(version.to_string());
+                    op_delete.set_if_version_match_from_if_not_changed();
                 }
             } else if capability.delete_with_if_match
-                && let Some(etag) = metadata.etag()
+                && let Some(etag) = op_delete.if_not_changed_etag()
             {
-                if let Some(explicit) = opts.if_match.as_deref() {
+                if let Some(explicit) = op_delete.if_match() {
                     if explicit != etag {
                         return Err(Error::new(
                             ErrorKind::ConditionNotMatch,
@@ -2844,7 +2841,7 @@ impl Operator {
                         .with_operation(Operation::Delete.into_static()));
                     }
                 } else {
-                    opts.if_match = Some(etag.to_string());
+                    op_delete.set_if_match_from_if_not_changed();
                 }
             } else if !capability.delete_with_if_version_match && !capability.delete_with_if_match {
                 return Err(Error::new(
@@ -2863,7 +2860,7 @@ impl Operator {
                 .with_operation(Operation::Delete.into_static()));
             }
         }
-        let op = OpPresign::new(OpDelete::from(opts), expire);
+        let op = OpPresign::new(op_delete, expire);
         let rp = srv.presign(&ctx, &path, op).await?;
         Ok(rp.into_presigned_request())
     }
diff --git a/core/core/src/types/read/futures_async_reader.rs b/core/core/src/types/read/futures_async_reader.rs
index 0cd814bfec..35ce8d4302 100644
--- a/core/core/src/types/read/futures_async_reader.rs
+++ b/core/core/src/types/read/futures_async_reader.rs
@@ -409,9 +409,9 @@ mod tests {
 
         async fn stat(&self, _: &OperationContext, _: &str, _: OpStat) -> Result<RpStat> {
             self.counts.stats.fetch_add(1, Ordering::SeqCst);
-            Ok(RpStat::new(
-                Metadata::new(EntryMode::FILE).with_content_length(self.content_length),
-            ))
+            let mut metadata = Metadata::builder(EntryMode::FILE);
+            metadata.content_length(self.content_length);
+            Ok(RpStat::new(metadata.build()))
         }
 
         fn read(&self, _: &OperationContext, _: &str, _: OpRead) -> Result<Self::Reader> {
@@ -490,9 +490,9 @@ mod tests {
             let content = self
                 .content
                 .slice(range.to_content_range(self.content.len())?);
-            let metadata =
-                Metadata::new(EntryMode::FILE).with_content_length(self.content.len() as u64);
-            Ok((RpRead::new(metadata), Box::new(content)))
+            let mut metadata = Metadata::builder(EntryMode::FILE);
+            metadata.content_length(self.content.len() as u64);
+            Ok((RpRead::new(metadata.build()), Box::new(content)))
         }
 
         async fn read(&self, range: BytesRange) -> Result<(RpRead, Buffer)> {
diff --git a/core/core/src/types/read/reader.rs b/core/core/src/types/read/reader.rs
index e05e6e358a..824b9ddb11 100644
--- a/core/core/src/types/read/reader.rs
+++ b/core/core/src/types/read/reader.rs
@@ -623,9 +623,11 @@ mod tests {
             }
 
             Ok((
-                RpRead::new(
-                    Metadata::new(EntryMode::FILE).with_content_length(self.content.len() as u64),
-                ),
+                RpRead::new({
+                    let mut metadata = Metadata::builder(EntryMode::FILE);
+                    metadata.content_length(self.content.len() as u64);
+                    metadata.build()
+                }),
                 Buffer::from(self.content.slice(start..end)),
             ))
         }
diff --git a/core/layers/concurrent-limit/src/lib.rs b/core/layers/concurrent-limit/src/lib.rs
index d5c3714e64..d6ccb3ece2 100644
--- a/core/layers/concurrent-limit/src/lib.rs
+++ b/core/layers/concurrent-limit/src/lib.rs
@@ -780,7 +780,7 @@ mod tests {
             }
 
             async fn stat(&self, _: &OperationContext, _: &str, _: OpStat) -> Result<RpStat> {
-                Ok(RpStat::new(Metadata::new(EntryMode::FILE)))
+                Ok(RpStat::new(Metadata::builder(EntryMode::FILE).build()))
             }
 
             async fn rename(
@@ -900,7 +900,11 @@ mod tests {
                 };
                 let req = http::Request::get("http://fake").body(data).unwrap();
                 let resp = self.ctx.http_transport().fetch(req).await?;
-                let rp = RpRead::new(Metadata::new(EntryMode::FILE).with_content_length(0));
+                let rp = RpRead::new({
+                    let mut metadata = Metadata::builder(EntryMode::FILE);
+                    metadata.content_length(0);
+                    metadata.build()
+                });
                 let stream = resp.into_body();
 
                 Ok((rp, Box::new(stream) as Box<dyn oio::ReadStreamDyn>))
@@ -949,9 +953,11 @@ mod tests {
             }
 
             async fn stat(&self, _: &OperationContext, _: &str, _: OpStat) -> Result<RpStat> {
-                Ok(RpStat::new(
-                    Metadata::new(EntryMode::FILE).with_content_length(self.content.len() as u64),
-                ))
+                Ok(RpStat::new({
+                    let mut metadata = Metadata::builder(EntryMode::FILE);
+                    metadata.content_length(self.content.len() as u64);
+                    metadata.build()
+                }))
             }
 
             fn write(&self, _: &OperationContext, _: &str, _: OpWrite) -> Result<Self::Writer> {
diff --git a/core/layers/foyer/src/full.rs b/core/layers/foyer/src/full.rs
index 0325d737c8..0eb1caf08b 100644
--- a/core/layers/foyer/src/full.rs
+++ b/core/layers/foyer/src/full.rs
@@ -23,6 +23,7 @@ use opendal_core::EntryMode;
 use opendal_core::Error;
 use opendal_core::Metadata;
 use opendal_core::Result;
+use opendal_core::options;
 use opendal_core::raw::OpRead;
 use opendal_core::raw::OpStat;
 use opendal_core::raw::RpRead;
@@ -66,7 +67,11 @@ impl FullReader {
     }
 
     fn full_object_rp(buffer: &Buffer) -> RpRead {
-        RpRead::new(Metadata::new(EntryMode::FILE).with_content_length(buffer.len() as _))
+        RpRead::new({
+            let mut metadata = Metadata::builder(EntryMode::FILE);
+            metadata.content_length(buffer.len() as _);
+            metadata.build()
+        })
     }
 
     fn slice_full_object(buffer: &Buffer, range: BytesRange) -> Buffer {
@@ -84,23 +89,17 @@ impl FullReader {
     /// Derive the `OpStat` used for cache fill from the reader's `OpRead`, so the
     /// stat observes the same conditions (version, if-match, ...) as the request.
     fn stat_args(&self) -> OpStat {
-        let mut op = OpStat::new();
-        if let Some(v) = self.args.version() {
-            op = op.with_version(v);
+        options::StatOptions {
+            version: self.args.version().map(str::to_owned),
+            if_match: self.args.if_match().map(str::to_owned),
+            if_none_match: self.args.if_none_match().map(str::to_owned),
+            if_version_match: self.args.if_version_match().map(str::to_owned),
+            if_version_not_match: self.args.if_version_not_match().map(str::to_owned),
+            if_modified_since: self.args.if_modified_since(),
+            if_unmodified_since: self.args.if_unmodified_since(),
+            ..Default::default()
         }
-        if let Some(v) = self.args.if_match() {
-            op = op.with_if_match(v);
-        }
-        if let Some(v) = self.args.if_none_match() {
-            op = op.with_if_none_match(v);
-        }
-        if let Some(v) = self.args.if_modified_since() {
-            op = op.with_if_modified_since(v);
-        }
-        if let Some(v) = self.args.if_unmodified_since() {
-            op = op.with_if_unmodified_since(v);
-        }
-        op
+        .into()
     }
 
     async fn fallback_open(
diff --git a/core/layers/foyer/src/lib.rs b/core/layers/foyer/src/lib.rs
index e35787d2e9..62bc3a4469 100644
--- a/core/layers/foyer/src/lib.rs
+++ b/core/layers/foyer/src/lib.rs
@@ -431,7 +431,11 @@ mod tests {
         }
 
         fn metadata(&self) -> Metadata {
-            Metadata::new(EntryMode::FILE).with_content_length(self.data.len() as _)
+            {
+                let mut metadata = Metadata::builder(EntryMode::FILE);
+                metadata.content_length(self.data.len() as _);
+                metadata.build()
+            }
         }
 
         fn rp_read(&self) -> RpRead {
@@ -662,7 +666,12 @@ mod tests {
             .apply_service(source);
         let ctx = service_context(&service);
 
-        let args = OpRead::default().with_version("v1").with_if_match("etag-1");
+        let (_, args, _) = options::ReadOptions {
+            version: Some("v1".to_owned()),
+            if_match: Some("etag-1".to_owned()),
+            ..Default::default()
+        }
+        .into();
         let reader = service.read(&ctx, "test", args).unwrap();
         let (_, mut stream) = reader.open(BytesRange::new(0, None)).await.unwrap();
         stream.read_all().await.unwrap();
diff --git a/core/layers/immutable-index/src/lib.rs b/core/layers/immutable-index/src/lib.rs
index 6999ae9664..48b4847a57 100644
--- a/core/layers/immutable-index/src/lib.rs
+++ b/core/layers/immutable-index/src/lib.rs
@@ -265,7 +265,7 @@ impl ImmutableDir {
             } else {
                 EntryMode::FILE
             };
-            let meta = Metadata::new(mode);
+            let meta = Metadata::builder(mode).build();
             oio::Entry::with(v, meta)
         })
     }
diff --git a/core/layers/mime-guess/src/lib.rs b/core/layers/mime-guess/src/lib.rs
index 7856492f68..e41f481794 100644
--- a/core/layers/mime-guess/src/lib.rs
+++ b/core/layers/mime-guess/src/lib.rs
@@ -96,7 +96,29 @@ fn opwrite_with_mime(path: &str, op: OpWrite) -> OpWrite {
     }
 
     if let Some(mime) = mime_from_path(path) {
-        return op.with_content_type(mime);
+        let (op, _) = options::WriteOptions {
+            append: op.append(),
+            concurrent: op.concurrent(),
+            content_type: Some(mime.to_owned()),
+            content_disposition: op.content_disposition().map(str::to_owned),
+            content_encoding: op.content_encoding().map(str::to_owned),
+            cache_control: op.cache_control().map(str::to_owned),
+            if_match: op.if_match().map(str::to_owned),
+            if_none_match: op.if_none_match().map(str::to_owned),
+            if_version_match: op.if_version_match().map(str::to_owned),
+            if_version_not_match: op.if_version_not_match().map(str::to_owned),
+            if_not_exists: op.if_not_exists(),
+            if_not_changed: op.if_not_changed(),
+            user_metadata: op.user_metadata().map(|metadata| {
+                metadata
+                    .into_iter()
+                    .map(|(key, value)| (key.to_owned(), value.to_owned()))
+                    .collect()
+            }),
+            ..Default::default()
+        }
+        .into();
+        return op;
     }
 
     op
@@ -109,7 +131,9 @@ fn rpstat_with_mime(path: &str, rp: RpStat) -> RpStat {
         }
 
         if let Some(mime) = mime_from_path(path) {
-            return metadata.with_content_type(mime.into());
+            let mut metadata = metadata.into_builder();
+            metadata.content_type(mime);
+            return metadata.build();
         }
 
         metadata
diff --git a/core/layers/retry/src/lib.rs b/core/layers/retry/src/lib.rs
index d015431275..9f5a9dbfbc 100644
--- a/core/layers/retry/src/lib.rs
+++ b/core/layers/retry/src/lib.rs
@@ -1127,7 +1127,11 @@ mod tests {
     impl oio::StreamRead for MockReader {
         async fn open(&self, range: BytesRange) -> Result<(RpRead, Box<dyn oio::ReadStreamDyn>)> {
             let backend = &self.backend;
-            let rp = RpRead::new(Metadata::new(EntryMode::FILE).with_content_length(0));
+            let rp = RpRead::new({
+                let mut metadata = Metadata::builder(EntryMode::FILE);
+                metadata.content_length(0);
+                metadata.build()
+            });
             let stream = MockReadStream {
                 buf: Bytes::from("Hello, World!").into(),
                 range,
@@ -1177,9 +1181,11 @@ mod tests {
         }
 
         async fn stat(&self, _: &OperationContext, _: &str, _: OpStat) -> Result<RpStat> {
-            Ok(RpStat::new(
-                Metadata::new(EntryMode::FILE).with_content_length(13),
-            ))
+            Ok(RpStat::new({
+                let mut metadata = Metadata::builder(EntryMode::FILE);
+                metadata.content_length(13);
+                metadata.build()
+            }))
         }
 
         fn read(&self, _: &OperationContext, path: &str, args: OpRead) -> Result<Self::Reader> {
@@ -1300,11 +1306,11 @@ mod tests {
                 .set_temporary()),
                 2 => Ok(Some(oio::Entry::new(
                     "hello",
-                    Metadata::new(EntryMode::FILE),
+                    Metadata::builder(EntryMode::FILE).build(),
                 ))),
                 3 => Ok(Some(oio::Entry::new(
                     "world",
-                    Metadata::new(EntryMode::FILE),
+                    Metadata::builder(EntryMode::FILE).build(),
                 ))),
                 4 => Err(
                     Error::new(ErrorKind::Unexpected, "retryable internal server error")
@@ -1312,11 +1318,11 @@ mod tests {
                 ),
                 5 => Ok(Some(oio::Entry::new(
                     "2023/",
-                    Metadata::new(EntryMode::DIR),
+                    Metadata::builder(EntryMode::DIR).build(),
                 ))),
                 6 => Ok(Some(oio::Entry::new(
                     "0208/",
-                    Metadata::new(EntryMode::DIR),
+                    Metadata::builder(EntryMode::DIR).build(),
                 ))),
                 7 => Ok(None),
                 _ => {
@@ -1401,7 +1407,7 @@ mod tests {
         }
 
         async fn close(&mut self) -> Result<Metadata> {
-            Ok(Metadata::default())
+            Ok(Metadata::builder(EntryMode::Unknown).build())
         }
 
         async fn abort(&mut self) -> Result<()> {
diff --git a/core/layers/route/src/lib.rs b/core/layers/route/src/lib.rs
index 951b0a644f..9143dfc7e7 100644
--- a/core/layers/route/src/lib.rs
+++ b/core/layers/route/src/lib.rs
@@ -509,7 +509,7 @@ mod tests {
 
         async fn stat(&self, _: &OperationContext, path: &str, _: OpStat) -> Result<RpStat> {
             if self.paths.lock().unwrap().contains(path) {
-                Ok(RpStat::new(Metadata::new(EntryMode::FILE)))
+                Ok(RpStat::new(Metadata::builder(EntryMode::FILE).build()))
             } else {
                 Err(Error::new(ErrorKind::NotFound, "path not found"))
             }
@@ -592,7 +592,7 @@ mod tests {
 
         async fn close(&mut self) -> Result<Metadata> {
             self.paths.lock().unwrap().insert(self.path.clone());
-            Ok(Metadata::new(EntryMode::FILE))
+            Ok(Metadata::builder(EntryMode::FILE).build())
         }
 
         async fn abort(&mut self) -> Result<()> {
diff --git a/core/services/aliyun-drive/src/backend.rs b/core/services/aliyun-drive/src/backend.rs
index 7077575671..46838e306e 100644
--- a/core/services/aliyun-drive/src/backend.rs
+++ b/core/services/aliyun-drive/src/backend.rs
@@ -262,7 +262,7 @@ impl Service for AliyunDriveBackend {
 
         Ok(oio::OneShotCopier::new(async move {
             if from == to {
-                Ok(Metadata::default())
+                Ok(Metadata::builder(EntryMode::Unknown).build())
             } else {
                 let res = core.get_by_path(&ctx, &from).await?;
                 let file: AliyunDriveFile =
@@ -300,7 +300,7 @@ impl Service for AliyunDriveBackend {
                     core.update_path(&ctx, &file_id, to_name).await?;
                 }
 
-                Ok(Metadata::default())
+                Ok(Metadata::builder(EntryMode::Unknown).build())
             }
         }))
     }
@@ -311,28 +311,26 @@ impl Service for AliyunDriveBackend {
             serde_json::from_reader(res.reader()).map_err(new_json_serialize_error)?;
 
         if file.path_type == "folder" {
-            let meta = Metadata::new(EntryMode::DIR).with_last_modified(
-                file.updated_at.parse::<Timestamp>().map_err(|e| {
-                    Error::new(ErrorKind::Unexpected, "parse last modified time").set_source(e)
-                })?,
-            );
+            let mut meta = Metadata::builder(EntryMode::DIR);
+            meta.last_modified(file.updated_at.parse::<Timestamp>().map_err(|e| {
+                Error::new(ErrorKind::Unexpected, "parse last modified time").set_source(e)
+            })?);
 
-            return Ok(RpStat::new(meta));
+            return Ok(RpStat::new(meta.build()));
         }
 
-        let mut meta = Metadata::new(EntryMode::FILE).with_last_modified(
-            file.updated_at.parse::<Timestamp>().map_err(|e| {
-                Error::new(ErrorKind::Unexpected, "parse last modified time").set_source(e)
-            })?,
-        );
+        let mut meta = Metadata::builder(EntryMode::FILE);
+        meta.last_modified(file.updated_at.parse::<Timestamp>().map_err(|e| {
+            Error::new(ErrorKind::Unexpected, "parse last modified time").set_source(e)
+        })?);
         if let Some(v) = file.size {
-            meta = meta.with_content_length(v);
+            meta.content_length(v);
         }
         if let Some(v) = file.content_type {
-            meta = meta.with_content_type(v);
+            meta.content_type(v);
         }
 
-        Ok(RpStat::new(meta))
+        Ok(RpStat::new(meta.build()))
     }
     fn read(&self, ctx: &OperationContext, path: &str, args: OpRead) -> Result<Self::Reader> {
         let output: oio::StreamReader<AliyunDriveReader> = {
diff --git a/core/services/aliyun-drive/src/lister.rs b/core/services/aliyun-drive/src/lister.rs
index fe122a7420..8b6a535571 100644
--- a/core/services/aliyun-drive/src/lister.rs
+++ b/core/services/aliyun-drive/src/lister.rs
@@ -96,14 +96,13 @@ impl oio::PageList for AliyunDriveLister {
 
         let offset = if ctx.token.is_empty() {
             // Push self into the list result.
-            ctx.entries.push_back(Entry::new(
-                &parent.path,
-                Metadata::new(EntryMode::DIR).with_last_modified(
-                    parent.updated_at.parse::<Timestamp>().map_err(|e| {
-                        Error::new(ErrorKind::Unexpected, "parse last modified time").set_source(e)
-                    })?,
-                ),
-            ));
+            ctx.entries.push_back(Entry::new(&parent.path, {
+                let mut metadata = Metadata::builder(EntryMode::DIR);
+                metadata.last_modified(parent.updated_at.parse::<Timestamp>().map_err(|e| {
+                    Error::new(ErrorKind::Unexpected, "parse last modified time").set_source(e)
+                })?);
+                metadata.build()
+            }));
             None
         } else {
             Some(ctx.token.clone())
@@ -132,23 +131,23 @@ impl oio::PageList for AliyunDriveLister {
         for item in result.items {
             let (path, mut md) = if item.path_type == "folder" {
                 let path = format!("{}{}/", parent.path.trim_start_matches('/'), item.name);
-                (path, Metadata::new(EntryMode::DIR))
+                (path, Metadata::builder(EntryMode::DIR))
             } else {
                 let path = format!("{}{}", parent.path.trim_start_matches('/'), item.name);
-                (path, Metadata::new(EntryMode::FILE))
+                (path, Metadata::builder(EntryMode::FILE))
             };
 
-            md = md.with_last_modified(item.updated_at.parse::<Timestamp>().map_err(|e| {
+            md.last_modified(item.updated_at.parse::<Timestamp>().map_err(|e| {
                 Error::new(ErrorKind::Unexpected, "parse last modified time").set_source(e)
             })?);
             if let Some(v) = item.size {
-                md = md.with_content_length(v);
+                md.content_length(v);
             }
             if let Some(v) = item.content_type {
-                md = md.with_content_type(v);
+                md.content_type(v);
             }
 
-            ctx.entries.push_back(Entry::new(&path, md));
+            ctx.entries.push_back(Entry::new(&path, md.build()));
         }
 
         let next_marker = result.next_marker.unwrap_or_default();
diff --git a/core/services/aliyun-drive/src/writer.rs b/core/services/aliyun-drive/src/writer.rs
index 8a557c5d69..061b63678c 100644
--- a/core/services/aliyun-drive/src/writer.rs
+++ b/core/services/aliyun-drive/src/writer.rs
@@ -104,7 +104,7 @@ impl oio::Write for AliyunDriveLazyWriter {
     async fn close(&mut self) -> Result<Metadata> {
         match &mut self.inner {
             Some(w) => w.close().await,
-            None => Ok(Metadata::default()),
+            None => Ok(Metadata::builder(EntryMode::Unknown).build()),
         }
     }
 
@@ -183,11 +183,11 @@ impl oio::Write for AliyunDriveWriter {
     async fn close(&mut self) -> Result<Metadata> {
         let (Some(upload_id), Some(file_id)) = (self.upload_id.as_ref(), self.file_id.as_ref())
         else {
-            return Ok(Metadata::default());
+            return Ok(Metadata::builder(EntryMode::Unknown).build());
         };
 
         self.core.complete(&self.ctx, file_id, upload_id).await?;
-        Ok(Metadata::default())
+        Ok(Metadata::builder(EntryMode::Unknown).build())
     }
 
     async fn abort(&mut self) -> Result<()> {
diff --git a/core/services/alluxio/src/core.rs b/core/services/alluxio/src/core.rs
index 33323db7ee..7fca180f1d 100644
--- a/core/services/alluxio/src/core.rs
+++ b/core/services/alluxio/src/core.rs
@@ -471,16 +471,16 @@ impl TryFrom<FileInfo> for Metadata {
 
     fn try_from(file_info: FileInfo) -> Result<Metadata> {
         let mut metadata = if file_info.folder {
-            Metadata::new(EntryMode::DIR)
+            Metadata::builder(EntryMode::DIR)
         } else {
-            Metadata::new(EntryMode::FILE)
+            Metadata::builder(EntryMode::FILE)
         };
         metadata
-            .set_content_length(file_info.length)
-            .set_last_modified(Timestamp::from_millisecond(
+            .content_length(file_info.length)
+            .last_modified(Timestamp::from_millisecond(
                 file_info.last_modification_time_ms,
             )?);
-        Ok(metadata)
+        Ok(metadata.build())
     }
 }
 
diff --git a/core/services/alluxio/src/writer.rs b/core/services/alluxio/src/writer.rs
index abb721ac52..a30528a571 100644
--- a/core/services/alluxio/src/writer.rs
+++ b/core/services/alluxio/src/writer.rs
@@ -60,11 +60,11 @@ impl oio::Write for AlluxioWriter {
 
     async fn close(&mut self) -> Result<Metadata> {
         let Some(stream_id) = self.stream_id else {
-            return Ok(Metadata::default());
+            return Ok(Metadata::builder(EntryMode::Unknown).build());
         };
         self.core.close(&self.ctx, stream_id).await?;
 
-        Ok(Metadata::default())
+        Ok(Metadata::builder(EntryMode::Unknown).build())
     }
 
     async fn abort(&mut self) -> Result<()> {
diff --git a/core/services/azblob/src/backend.rs b/core/services/azblob/src/backend.rs
index 4d465633bf..24b66d6dc5 100644
--- a/core/services/azblob/src/backend.rs
+++ b/core/services/azblob/src/backend.rs
@@ -503,17 +503,17 @@ impl Service for AzblobBackend {
         match status {
             StatusCode::OK => {
                 let headers = resp.headers();
-                let mut meta = parse_into_metadata(path, headers)?;
+                let mut meta = parse_into_metadata(path, headers)?.into_builder();
                 if let Some(version_id) = parse_header_to_str(headers, X_MS_VERSION_ID)? {
-                    meta.set_version(version_id);
+                    meta.version(version_id);
                 }
 
                 let user_meta = parse_prefixed_headers(headers, X_MS_META_PREFIX);
                 if !user_meta.is_empty() {
-                    meta = meta.with_user_metadata(user_meta);
+                    meta.user_metadata(user_meta);
                 }
 
-                Ok(RpStat::new(meta))
+                Ok(RpStat::new(meta.build()))
             }
             _ => Err(parse_error(error_ctx, resp)),
         }
diff --git a/core/services/azblob/src/copier.rs b/core/services/azblob/src/copier.rs
index fbd1a0ea25..5ac9b8bd87 100644
--- a/core/services/azblob/src/copier.rs
+++ b/core/services/azblob/src/copier.rs
@@ -79,10 +79,11 @@ pub struct AzblobCopier {
 
 impl oio::BlockCopy for AzblobCopier {
     async fn source_metadata(&self) -> Result<Metadata> {
-        let mut args = OpStat::default();
-        if let Some(version) = self.args.source_version() {
-            args = args.with_version(version);
+        let args = options::StatOptions {
+            version: self.args.source_version().map(str::to_owned),
+            ..Default::default()
         }
+        .into();
 
         let resp = self
             .core
@@ -92,11 +93,11 @@ impl oio::BlockCopy for AzblobCopier {
         match resp.status() {
             StatusCode::OK => {
                 let headers = resp.headers();
-                let mut meta = parse_into_metadata(&self.from, headers)?;
+                let mut meta = parse_into_metadata(&self.from, headers)?.into_builder();
                 if let Some(version_id) = parse_header_to_str(headers, X_MS_VERSION_ID)? {
-                    meta.set_version(version_id);
+                    meta.version(version_id);
                 }
-                Ok(meta)
+                Ok(meta.build())
             }
             _ => Err(parse_error(
                 ErrorContext::new(ServiceOperation("GetBlobProperties")),
diff --git a/core/services/azblob/src/core.rs b/core/services/azblob/src/core.rs
index af64a04c07..e60ad89eee 100644
--- a/core/services/azblob/src/core.rs
+++ b/core/services/azblob/src/core.rs
@@ -1145,9 +1145,12 @@ mod tests {
 
         let mut meta = HashMap::new();
         meta.insert("k".to_string(), "v".to_string());
-        let args = OpWrite::default()
-            .with_content_type("application/json")
-            .with_user_metadata(meta);
+        let (args, _) = options::WriteOptions {
+            content_type: Some("application/json".to_owned()),
+            user_metadata: Some(meta),
+            ..Default::default()
+        }
+        .into();
 
         let req = core
             .azblob_complete_put_block_list_request("a.txt", vec![Uuid::nil()], &args)
diff --git a/core/services/azblob/src/lister.rs b/core/services/azblob/src/lister.rs
index 6262dddb63..8eb9590fea 100644
--- a/core/services/azblob/src/lister.rs
+++ b/core/services/azblob/src/lister.rs
@@ -94,7 +94,7 @@ impl oio::PageList for AzblobLister {
         for prefix in prefixes {
             let de = oio::Entry::new(
                 &build_rel_path(&self.core.root, &prefix.name),
-                Metadata::new(EntryMode::DIR),
+                Metadata::builder(EntryMode::DIR).build(),
             );
 
             ctx.entries.push_back(de)
@@ -106,17 +106,16 @@ impl oio::PageList for AzblobLister {
                 path = "/".to_string();
             }
 
-            let meta = Metadata::new(EntryMode::from_path(&path))
-                // Keep fit with ETag header.
-                .with_etag(format!("\"{}\"", object.properties.etag.as_str()))
-                .with_content_length(object.properties.content_length)
-                .with_content_md5(object.properties.content_md5)
-                .with_content_type(object.properties.content_type)
-                .with_last_modified(Timestamp::parse_rfc2822(
+            let mut meta = Metadata::builder(EntryMode::from_path(&path));
+            meta.etag(format!("\"{}\"", object.properties.etag.as_str()))
+                .content_length(object.properties.content_length)
+                .content_md5(object.properties.content_md5)
+                .content_type(object.properties.content_type)
+                .last_modified(Timestamp::parse_rfc2822(
                     object.properties.last_modified.as_str(),
                 )?);
 
-            let de = oio::Entry::with(path, meta);
+            let de = oio::Entry::with(path, meta.build());
             ctx.entries.push_back(de);
         }
 
diff --git a/core/services/azblob/src/writer.rs b/core/services/azblob/src/writer.rs
index 347b4d77b6..e2d0558523 100644
--- a/core/services/azblob/src/writer.rs
+++ b/core/services/azblob/src/writer.rs
@@ -52,21 +52,21 @@ impl AzblobWriter {
     // skip extracting `content-md5` here, as it pertains to the content of the request rather than
     // the content of the block itself for the `append` and `complete put block list` operations.
     pub(crate) fn parse_metadata(headers: &http::HeaderMap) -> Result<Metadata> {
-        let mut metadata = Metadata::default();
+        let mut metadata = Metadata::builder(EntryMode::Unknown);
 
         if let Some(last_modified) = parse_last_modified(headers)? {
-            metadata.set_last_modified(last_modified);
+            metadata.last_modified(last_modified);
         }
         let etag = parse_etag(headers)?;
         if let Some(etag) = etag {
-            metadata.set_etag(etag);
+            metadata.etag(etag);
         }
         let version_id = parse_header_to_str(headers, X_MS_VERSION_ID)?;
         if let Some(version_id) = version_id {
-            metadata.set_version(version_id);
+            metadata.version(version_id);
         }
 
-        Ok(metadata)
+        Ok(metadata.build())
     }
 
     fn error_context(&self, service_operation: ServiceOperation) -> ErrorContext {
@@ -154,13 +154,13 @@ impl oio::BlockWrite for AzblobWriter {
 
         let status = resp.status();
 
-        let mut meta = AzblobWriter::parse_metadata(resp.headers())?;
+        let mut meta = AzblobWriter::parse_metadata(resp.headers())?.into_builder();
         let md5 = parse_content_md5(resp.headers())?;
         if let Some(md5) = md5 {
-            meta.set_content_md5(md5);
+            meta.content_md5(md5);
         }
         match status {
-            StatusCode::CREATED | StatusCode::OK => Ok(meta),
+            StatusCode::CREATED | StatusCode::OK => Ok(meta.build()),
             _ => Err(parse_error(
                 self.error_context(ServiceOperation("PutBlob")),
                 resp,
diff --git a/core/services/azdls/src/backend.rs b/core/services/azdls/src/backend.rs
index a6739018f7..7b2cdcf1ab 100644
--- a/core/services/azdls/src/backend.rs
+++ b/core/services/azdls/src/backend.rs
@@ -428,7 +428,7 @@ impl Service for AzdlsBackend {
         // Stat root always returns a DIR.
         // TODO: include metadata for the root (#4746)
         if path == "/" {
-            return Ok(RpStat::new(Metadata::new(EntryMode::DIR)));
+            return Ok(RpStat::new(Metadata::builder(EntryMode::DIR).build()));
         }
 
         let metadata = self.core.azdls_stat_metadata(ctx, path, &args).await?;
diff --git a/core/services/azdls/src/core.rs b/core/services/azdls/src/core.rs
index 54a5625de9..6dcb4d6977 100644
--- a/core/services/azdls/src/core.rs
+++ b/core/services/azdls/src/core.rs
@@ -203,7 +203,11 @@ impl AzdlsCore {
         if let Some(user_metadata) = args.user_metadata()
             && !user_metadata.is_empty()
         {
-            req = req.header(X_MS_PROPERTIES, encode_user_metadata(user_metadata));
+            let user_metadata = user_metadata
+                .into_iter()
+                .map(|(key, value)| (key.to_owned(), value.to_owned()))
+                .collect();
+            req = req.header(X_MS_PROPERTIES, encode_user_metadata(&user_metadata));
         }
 
         let operation = if resource == DIRECTORY {
@@ -393,16 +397,16 @@ impl AzdlsCore {
         }
 
         let headers = resp.headers();
-        let mut meta = parse_into_metadata(path, headers)?;
+        let mut meta = parse_into_metadata(path, headers)?.into_builder();
 
         if let Some(version_id) = parse_header_to_str(headers, X_MS_VERSION_ID)? {
-            meta.set_version(version_id);
+            meta.version(version_id);
         }
 
         if let Some(value) = parse_header_to_str(headers, X_MS_PROPERTIES)? {
             let user_meta = decode_user_metadata(value);
             if !user_meta.is_empty() {
-                meta = meta.with_user_metadata(user_meta);
+                meta.user_metadata(user_meta);
             }
         }
 
@@ -425,8 +429,14 @@ impl AzdlsCore {
             })?;
 
         match resource {
-            FILE => Ok(meta.with_mode(EntryMode::FILE)),
-            DIRECTORY => Ok(meta.with_mode(EntryMode::DIR)),
+            FILE => {
+                meta.mode(EntryMode::FILE);
+                Ok(meta.build())
+            }
+            DIRECTORY => {
+                meta.mode(EntryMode::DIR);
+                Ok(meta.build())
+            }
             v => Err(Error::new(
                 ErrorKind::Unexpected,
                 "azdls returns an unknown x-ms-resource-type",
diff --git a/core/services/azdls/src/lister.rs b/core/services/azdls/src/lister.rs
index b01619d2d4..1569db471e 100644
--- a/core/services/azdls/src/lister.rs
+++ b/core/services/azdls/src/lister.rs
@@ -72,7 +72,7 @@ impl oio::PageList for AzdlsLister {
 
         // Return self at the first page.
         if ctx.token.is_empty() && !ctx.done {
-            let e = oio::Entry::new(&self.path, Metadata::new(EntryMode::DIR));
+            let e = oio::Entry::new(&self.path, Metadata::builder(EntryMode::DIR).build());
             ctx.entries.push_back(e);
         }
 
@@ -100,21 +100,20 @@ impl oio::PageList for AzdlsLister {
                 EntryMode::FILE
             };
 
-            let meta = Metadata::new(mode)
-                // Keep fit with ETag header.
-                .with_etag(format!("\"{}\"", object.etag))
-                .with_content_length(object.content_length.parse().map_err(|err| {
+            let mut meta = Metadata::builder(mode);
+            meta.etag(format!("\"{}\"", object.etag))
+                .content_length(object.content_length.parse().map_err(|err| {
                     Error::new(ErrorKind::Unexpected, "content length is not valid integer")
                         .set_source(err)
                 })?)
-                .with_last_modified(Timestamp::parse_rfc2822(&object.last_modified)?);
+                .last_modified(Timestamp::parse_rfc2822(&object.last_modified)?);
 
             let mut path = build_rel_path(&self.core.root, &object.name);
             if mode.is_dir() {
                 path += "/"
             };
 
-            let de = oio::Entry::new(&path, meta);
+            let de = oio::Entry::new(&path, meta.build());
 
             ctx.entries.push_back(de);
         }
diff --git a/core/services/azdls/src/writer.rs b/core/services/azdls/src/writer.rs
index 3d25ed7f4b..48a83f6788 100644
--- a/core/services/azdls/src/writer.rs
+++ b/core/services/azdls/src/writer.rs
@@ -91,21 +91,21 @@ impl AzdlsWriter {
     }
 
     fn parse_metadata(headers: &http::HeaderMap) -> Result<Metadata> {
-        let mut metadata = Metadata::default();
+        let mut metadata = Metadata::builder(EntryMode::Unknown);
 
         if let Some(last_modified) = parse_last_modified(headers)? {
-            metadata.set_last_modified(last_modified);
+            metadata.last_modified(last_modified);
         }
         let etag = parse_etag(headers)?;
         if let Some(etag) = etag {
-            metadata.set_etag(etag);
+            metadata.etag(etag);
         }
         let version_id = parse_header_to_str(headers, X_MS_VERSION_ID)?;
         if let Some(version_id) = version_id {
-            metadata.set_version(version_id);
+            metadata.version(version_id);
         }
 
-        Ok(metadata)
+        Ok(metadata.build())
     }
 }
 
@@ -133,11 +133,11 @@ impl oio::PositionWrite for AzdlsWriter {
             .azdls_flush(&self.ctx, &self.path, size, true)
             .await?;
 
-        let mut meta = AzdlsWriter::parse_metadata(resp.headers())?;
-        meta.set_content_length(size);
+        let mut meta = AzdlsWriter::parse_metadata(resp.headers())?.into_builder();
+        meta.content_length(size);
 
         match resp.status() {
-            StatusCode::OK | StatusCode::ACCEPTED => Ok(meta),
+            StatusCode::OK | StatusCode::ACCEPTED => Ok(meta.build()),
             _ => Err(
                 parse_error(ErrorContext::new(ServiceOperation("FlushData")), resp)
                     .with_operation("Backend::azdls_flush_request"),
@@ -201,15 +201,15 @@ impl oio::AppendWrite for AzdlsWriter {
             .azdls_append(&self.ctx, &self.path, Some(size), offset, true, false, body)
             .await?;
 
-        let mut meta = AzdlsWriter::parse_metadata(resp.headers())?;
+        let mut meta = AzdlsWriter::parse_metadata(resp.headers())?.into_builder();
         let md5 = parse_content_md5(resp.headers())?;
         if let Some(md5) = md5 {
-            meta.set_content_md5(md5);
+            meta.content_md5(md5);
         }
-        meta.set_content_length(offset + size);
+        meta.content_length(offset + size);
 
         match resp.status() {
-            StatusCode::OK | StatusCode::ACCEPTED => Ok(meta),
+            StatusCode::OK | StatusCode::ACCEPTED => Ok(meta.build()),
             _ => Err(
                 parse_error(ErrorContext::new(ServiceOperation("AppendData")), resp)
                     .with_operation("Backend::azdls_append_request"),
diff --git a/core/services/azfile/src/backend.rs b/core/services/azfile/src/backend.rs
index 5d8a316777..8e43ab32b1 100644
--- a/core/services/azfile/src/backend.rs
+++ b/core/services/azfile/src/backend.rs
@@ -334,12 +334,12 @@ impl Service for AzfileBackend {
         match status {
             StatusCode::OK => {
                 let headers = resp.headers();
-                let mut meta = parse_into_metadata(path, headers)?;
+                let mut meta = parse_into_metadata(path, headers)?.into_builder();
                 let user_meta = parse_prefixed_headers(headers, X_MS_META_PREFIX);
                 if !user_meta.is_empty() {
-                    meta = meta.with_user_metadata(user_meta);
+                    meta.user_metadata(user_meta);
                 }
-                Ok(RpStat::new(meta))
+                Ok(RpStat::new(meta.build()))
             }
             _ => Err(parse_error(
                 ErrorContext::new(if path.ends_with('/') {
diff --git a/core/services/azfile/src/lister.rs b/core/services/azfile/src/lister.rs
index 7fd8de8991..f65747301f 100644
--- a/core/services/azfile/src/lister.rs
+++ b/core/services/azfile/src/lister.rs
@@ -72,7 +72,7 @@ impl oio::PageList for AzfileLister {
 
         // Return self at the first page.
         if ctx.token.is_empty() && !ctx.done {
-            let e = oio::Entry::new(&self.path, Metadata::new(EntryMode::DIR));
+            let e = oio::Entry::new(&self.path, Metadata::builder(EntryMode::DIR).build());
             ctx.entries.push_back(e);
         }
 
@@ -88,22 +88,22 @@ impl oio::PageList for AzfileLister {
         }
 
         for file in results.entries.file {
-            let mut meta = Metadata::new(EntryMode::FILE)
-                .with_etag(file.properties.etag)
-                .with_last_modified(Timestamp::parse_rfc2822(&file.properties.last_modified)?);
+            let mut meta = Metadata::builder(EntryMode::FILE);
+            meta.etag(file.properties.etag)
+                .last_modified(Timestamp::parse_rfc2822(&file.properties.last_modified)?);
             if let Some(size) = file.properties.content_length {
-                meta.set_content_length(size);
+                meta.content_length(size);
             }
             let path = self.path.clone().trim_start_matches('/').to_string() + &file.name;
-            ctx.entries.push_back(oio::Entry::new(&path, meta));
+            ctx.entries.push_back(oio::Entry::new(&path, meta.build()));
         }
 
         for dir in results.entries.directory {
-            let meta = Metadata::new(EntryMode::DIR)
-                .with_etag(dir.properties.etag)
-                .with_last_modified(Timestamp::parse_rfc2822(&dir.properties.last_modified)?);
+            let mut meta = Metadata::builder(EntryMode::DIR);
+            meta.etag(dir.properties.etag)
+                .last_modified(Timestamp::parse_rfc2822(&dir.properties.last_modified)?);
             let path = self.path.clone().trim_start_matches('/').to_string() + &dir.name + "/";
-            ctx.entries.push_back(oio::Entry::new(&path, meta));
+            ctx.entries.push_back(oio::Entry::new(&path, meta.build()));
         }
 
         Ok(())
diff --git a/core/services/azfile/src/writer.rs b/core/services/azfile/src/writer.rs
index 87951e9456..5806befd6d 100644
--- a/core/services/azfile/src/writer.rs
+++ b/core/services/azfile/src/writer.rs
@@ -50,17 +50,17 @@ impl AzfileWriter {
     }
 
     fn parse_metadata(headers: &http::HeaderMap) -> Result<Metadata> {
-        let mut metadata = Metadata::default();
+        let mut metadata = Metadata::builder(EntryMode::Unknown);
 
         if let Some(last_modified) = parse_last_modified(headers)? {
-            metadata.set_last_modified(last_modified);
+            metadata.last_modified(last_modified);
         }
         let etag = parse_etag(headers)?;
         if let Some(etag) = etag {
-            metadata.set_etag(etag);
+            metadata.etag(etag);
         }
 
-        Ok(metadata)
+        Ok(metadata.build())
     }
 }
 
@@ -90,10 +90,10 @@ impl oio::OneShotWrite for AzfileWriter {
             .azfile_update(&self.ctx, &self.path, size as u64, 0, bs)
             .await?;
         let status = resp.status();
-        let mut meta = AzfileWriter::parse_metadata(resp.headers())?;
-        meta.set_content_length(size as u64);
+        let mut meta = AzfileWriter::parse_metadata(resp.headers())?.into_builder();
+        meta.content_length(size as u64);
         match status {
-            StatusCode::OK | StatusCode::CREATED => Ok(meta),
+            StatusCode::OK | StatusCode::CREATED => Ok(meta.build()),
             _ => Err(
                 parse_error(ErrorContext::new(ServiceOperation("PutRange")), resp)
                     .with_operation("Backend::azfile_update"),
@@ -129,10 +129,10 @@ impl oio::AppendWrite for AzfileWriter {
             .await?;
 
         let status = resp.status();
-        let mut meta = AzfileWriter::parse_metadata(resp.headers())?;
-        meta.set_content_length(offset + size);
+        let mut meta = AzfileWriter::parse_metadata(resp.headers())?.into_builder();
+        meta.content_length(offset + size);
         match status {
-            StatusCode::OK | StatusCode::CREATED => Ok(meta),
+            StatusCode::OK | StatusCode::CREATED => Ok(meta.build()),
             _ => Err(
                 parse_error(ErrorContext::new(ServiceOperation("PutRange")), resp)
                     .with_operation("Backend::azfile_update"),
diff --git a/core/services/b2/src/backend.rs b/core/services/b2/src/backend.rs
index 38f926afa1..5a11150a06 100644
--- a/core/services/b2/src/backend.rs
+++ b/core/services/b2/src/backend.rs
@@ -250,7 +250,7 @@ impl Service for B2Backend {
     async fn stat(&self, ctx: &OperationContext, path: &str, _args: OpStat) -> Result<RpStat> {
         // Stat root always returns a DIR.
         if path == "/" {
-            return Ok(RpStat::new(Metadata::new(EntryMode::DIR)));
+            return Ok(RpStat::new(Metadata::builder(EntryMode::DIR).build()));
         }
 
         let delimiter = if path.ends_with('/') { Some("/") } else { None };
@@ -336,7 +336,7 @@ impl Service for B2Backend {
             let status = resp.status();
 
             match status {
-                StatusCode::OK => Ok(Metadata::default()),
+                StatusCode::OK => Ok(Metadata::builder(EntryMode::Unknown).build()),
                 _ => Err(parse_error(
                     ErrorContext::new(ServiceOperation("CopyFile")),
                     resp,
diff --git a/core/services/b2/src/core.rs b/core/services/b2/src/core.rs
index 46cefda244..f60b6d3f46 100644
--- a/core/services/b2/src/core.rs
+++ b/core/services/b2/src/core.rs
@@ -340,7 +340,7 @@ impl B2Core {
         // B2 uses fileInfo field for custom file info in start_large_file API.
         if let Some(user_metadata) = args.user_metadata() {
             let file_info: HashMap<String, String> = user_metadata
-                .iter()
+                .into_iter()
                 .map(|(k, v)| (k.to_string(), percent_encode_path(v)))
                 .collect();
             start_large_file_request.file_info = Some(file_info);
@@ -798,19 +798,19 @@ pub struct File {
 
 pub(super) fn parse_file_info(file: &File) -> Metadata {
     if file.file_name.ends_with('/') {
-        return Metadata::new(EntryMode::DIR);
+        return Metadata::builder(EntryMode::DIR).build();
     }
 
-    let mut metadata = Metadata::new(EntryMode::FILE);
+    let mut metadata = Metadata::builder(EntryMode::FILE);
 
-    metadata.set_content_length(file.content_length);
+    metadata.content_length(file.content_length);
 
     if let Some(content_md5) = &file.content_md5 {
-        metadata.set_content_md5(content_md5);
+        metadata.content_md5(content_md5);
     }
 
     if let Some(content_type) = &file.content_type {
-        metadata.set_content_type(content_type);
+        metadata.content_type(content_type);
     }
 
     // Parse user metadata from file_info
@@ -823,11 +823,11 @@ pub(super) fn parse_file_info(file: &File) -> Metadata {
             .map(|(k, v)| (k.to_lowercase(), percent_decode_path(v)))
             .collect();
         if !user_metadata.is_empty() {
-            metadata = metadata.with_user_metadata(user_metadata);
+            metadata.user_metadata(user_metadata);
         }
     }
 
-    metadata
+    metadata.build()
 }
 
 #[derive(Debug, Serialize)]
diff --git a/core/services/b2/src/writer.rs b/core/services/b2/src/writer.rs
index 321abe885d..15812624a8 100644
--- a/core/services/b2/src/writer.rs
+++ b/core/services/b2/src/writer.rs
@@ -49,19 +49,19 @@ impl B2Writer {
     }
 
     pub fn parse_body_into_meta(path: &str, resp: UploadResponse) -> Metadata {
-        let mut meta = Metadata::new(EntryMode::from_path(path));
+        let mut meta = Metadata::builder(EntryMode::from_path(path));
 
         if let Some(md5) = resp.content_md5 {
-            meta.set_content_md5(&md5);
+            meta.content_md5(&md5);
         }
 
         if let Some(content_type) = resp.content_type {
-            meta.set_content_type(&content_type);
+            meta.content_type(&content_type);
         }
 
-        meta.set_content_length(resp.content_length);
+        meta.content_length(resp.content_length);
 
-        meta
+        meta.build()
     }
 }
 
diff --git a/core/services/cacache/src/backend.rs b/core/services/cacache/src/backend.rs
index 1424fd1e58..a66c3aae6a 100644
--- a/core/services/cacache/src/backend.rs
+++ b/core/services/cacache/src/backend.rs
@@ -113,14 +113,14 @@ impl Service for CacacheBackend {
 
         match metadata {
             Some(meta) => {
-                let mut md = Metadata::new(EntryMode::FILE);
-                md.set_content_length(meta.size as u64);
+                let mut md = Metadata::builder(EntryMode::FILE);
+                md.content_length(meta.size as u64);
                 // Convert u128 milliseconds to Timestamp
                 let millis = meta.time as i64;
                 if let Ok(dt) = Timestamp::from_millisecond(millis) {
-                    md.set_last_modified(dt);
+                    md.last_modified(dt);
                 }
-                Ok(RpStat::new(md))
+                Ok(RpStat::new(md.build()))
             }
             None => Err(Error::new(ErrorKind::NotFound, "entry not found")),
         }
diff --git a/core/services/cacache/src/reader.rs b/core/services/cacache/src/reader.rs
index 402f8fb963..3528e34bc8 100644
--- a/core/services/cacache/src/reader.rs
+++ b/core/services/cacache/src/reader.rs
@@ -44,7 +44,11 @@ impl oio::StreamRead for CacacheReader {
             Some(bytes) => {
                 let content_length = bytes.len() as u64;
                 let buffer = Buffer::from(bytes.slice(range.to_content_range(bytes.len())?));
-                let metadata = Metadata::new(EntryMode::FILE).with_content_length(content_length);
+                let metadata = {
+                    let mut metadata = Metadata::builder(EntryMode::FILE);
+                    metadata.content_length(content_length);
+                    metadata.build()
+                };
                 Ok((
                     RpRead::new(metadata),
                     Box::new(buffer) as Box<dyn oio::ReadStreamDyn>,
diff --git a/core/services/cacache/src/writer.rs b/core/services/cacache/src/writer.rs
index 7abfe94b0c..e1b46441bf 100644
--- a/core/services/cacache/src/writer.rs
+++ b/core/services/cacache/src/writer.rs
@@ -50,7 +50,11 @@ impl oio::Write for CacacheWriter {
 
         self.core.set(&self.path, buf.to_bytes()).await?;
 
-        let meta = Metadata::new(EntryMode::from_path(&self.path)).with_content_length(length);
+        let meta = {
+            let mut metadata = Metadata::builder(EntryMode::from_path(&self.path));
+            metadata.content_length(length);
+            metadata.build()
+        };
         Ok(meta)
     }
 
diff --git a/core/services/cloudflare-kv/src/backend.rs b/core/services/cloudflare-kv/src/backend.rs
index a57a8ea42a..a344341b7c 100644
--- a/core/services/cloudflare-kv/src/backend.rs
+++ b/core/services/cloudflare-kv/src/backend.rs
@@ -275,7 +275,7 @@ impl Service for CloudflareKvBackend {
                     if let Some(entries) = list_result.result
                         && !entries.is_empty()
                     {
-                        return Ok(RpStat::new(Metadata::new(EntryMode::DIR)));
+                        return Ok(RpStat::new(Metadata::builder(EntryMode::DIR).build()));
                     }
 
                     // Empty or no results means not found
@@ -366,16 +366,16 @@ impl Service for CloudflareKvBackend {
             ));
         }
 
-        let meta = Metadata::new(if metadata.is_dir {
+        let mut meta = Metadata::builder(if metadata.is_dir {
             EntryMode::DIR
         } else {
             EntryMode::FILE
-        })
-        .with_etag(metadata.etag)
-        .with_content_length(metadata.content_length as u64)
-        .with_last_modified(metadata.last_modified.parse::<Timestamp>()?);
+        });
+        meta.etag(metadata.etag)
+            .content_length(metadata.content_length as u64)
+            .last_modified(metadata.last_modified.parse::<Timestamp>()?);
 
-        Ok(RpStat::new(meta))
+        Ok(RpStat::new(meta.build()))
     }
     fn read(&self, ctx: &OperationContext, path: &str, args: OpRead) -> Result<Self::Reader> {
         let output: oio::StreamReader<CloudflareKvReader> = {
diff --git a/core/services/cloudflare-kv/src/lister.rs b/core/services/cloudflare-kv/src/lister.rs
index dd02609e01..798bae0884 100644
--- a/core/services/cloudflare-kv/src/lister.rs
+++ b/core/services/cloudflare-kv/src/lister.rs
@@ -84,14 +84,16 @@ impl CloudflareKvLister {
         }
 
         let entry_metadata = if name.ends_with('/') {
-            Metadata::new(EntryMode::DIR)
-                .with_etag(build_tmp_path_of(&name))
-                .with_content_length(0)
+            let mut metadata = Metadata::builder(EntryMode::DIR);
+            metadata.etag(build_tmp_path_of(&name)).content_length(0);
+            metadata.build()
         } else {
-            Metadata::new(EntryMode::FILE)
-                .with_etag(metadata.etag)
-                .with_content_length(metadata.content_length as u64)
-                .with_last_modified(metadata.last_modified.parse::<Timestamp>()?)
+            let mut result = Metadata::builder(EntryMode::FILE);
+            result
+                .etag(&metadata.etag)
+                .content_length(metadata.content_length as u64)
+                .last_modified(metadata.last_modified.parse::<Timestamp>()?);
+            result.build()
         };
 
         Ok(oio::Entry::new(&name, entry_metadata))
@@ -108,12 +110,13 @@ impl CloudflareKvLister {
             ctx.entries.push_back(entry);
         } else if !result.is_empty() {
             let path_name = relative_to_root(root, &self.path);
-            let entry = oio::Entry::new(
-                &format!("{path_name}/"),
-                Metadata::new(EntryMode::DIR)
-                    .with_etag(build_tmp_path_of(&path_name))
-                    .with_content_length(0),
-            );
+            let entry = oio::Entry::new(&format!("{path_name}/"), {
+                let mut metadata = Metadata::builder(EntryMode::DIR);
+                metadata
+                    .etag(build_tmp_path_of(&path_name))
+                    .content_length(0);
+                metadata.build()
+            });
             ctx.entries.push_back(entry);
         }
         ctx.done = true;
diff --git a/core/services/cloudflare-kv/src/reader.rs b/core/services/cloudflare-kv/src/reader.rs
index 3469a353f3..b7b368be9a 100644
--- a/core/services/cloudflare-kv/src/reader.rs
+++ b/core/services/cloudflare-kv/src/reader.rs
@@ -139,7 +139,11 @@ impl oio::StreamRead for CloudflareKvReader {
 
         let total_size = resp_body.len() as u64;
         let buffer = resp_body.slice(range.to_content_range(resp_body.len())?);
-        let metadata = Metadata::new(EntryMode::FILE).with_content_length(total_size);
+        let metadata = {
+            let mut metadata = Metadata::builder(EntryMode::FILE);
+            metadata.content_length(total_size);
+            metadata.build()
+        };
         Ok((
             RpRead::new(metadata),
             Box::new(buffer) as Box<dyn oio::ReadStreamDyn>,
diff --git a/core/services/cloudflare-kv/src/writer.rs b/core/services/cloudflare-kv/src/writer.rs
index 96fd49c2e9..af549b6b07 100644
--- a/core/services/cloudflare-kv/src/writer.rs
+++ b/core/services/cloudflare-kv/src/writer.rs
@@ -55,12 +55,12 @@ impl oio::OneShotWrite for CloudflareWriter {
 
         match status {
             StatusCode::OK => {
-                let mut metadata = Metadata::default();
-                metadata.set_etag(&cf_kv_metadata.etag);
-                metadata.set_last_modified(cf_kv_metadata.last_modified.parse::<Timestamp>()?);
-                metadata.set_content_length(cf_kv_metadata.content_length as u64);
+                let mut metadata = Metadata::builder(EntryMode::Unknown);
+                metadata.etag(&cf_kv_metadata.etag);
+                metadata.last_modified(cf_kv_metadata.last_modified.parse::<Timestamp>()?);
+                metadata.content_length(cf_kv_metadata.content_length as u64);
 
-                Ok(metadata)
+                Ok(metadata.build())
             }
             _ => Err(parse_error(
                 ErrorContext::new(ServiceOperation("WriteValue")),
diff --git a/core/services/compfs/src/backend.rs b/core/services/compfs/src/backend.rs
index 67b10014b9..49d788fc0d 100644
--- a/core/services/compfs/src/backend.rs
+++ b/core/services/compfs/src/backend.rs
@@ -160,10 +160,9 @@ impl Service for CompfsBackend {
             EntryMode::Unknown
         };
         let last_mod = Timestamp::try_from(meta.modified().map_err(new_std_io_error)?)?;
-        let ret = Metadata::new(mode)
-            .with_last_modified(last_mod)
-            .with_content_length(meta.len());
-        Ok(RpStat::new(ret))
+        let mut ret = Metadata::builder(mode);
+        ret.last_modified(last_mod).content_length(meta.len());
+        Ok(RpStat::new(ret.build()))
     }
 
     fn delete(&self, _ctx: &OperationContext) -> Result<Self::Deleter> {
@@ -203,7 +202,7 @@ impl Service for CompfsBackend {
                 let (mut from, mut to) = (Cursor::new(from), Cursor::new(to));
                 compio::io::copy(&mut from, &mut to).await?;
 
-                Ok(Metadata::default())
+                Ok(Metadata::builder(EntryMode::Unknown).build())
             })
             .await
         }))
diff --git a/core/services/compfs/src/lister.rs b/core/services/compfs/src/lister.rs
index 25f0c56a23..aac0b5a869 100644
--- a/core/services/compfs/src/lister.rs
+++ b/core/services/compfs/src/lister.rs
@@ -71,14 +71,18 @@ fn next_entry(read_dir: &mut ReadDir, root: &Path) -> std::io::Result<Option<oio
                 Err(err) if err.kind() == std::io::ErrorKind::NotFound => continue,
                 Err(err) => return Err(err),
             };
+            oio::Entry::new(&rel_path, {
+                let mut metadata = Metadata::builder(EntryMode::FILE);
+                metadata.content_length(de_metadata.len());
+                metadata.build()
+            })
+        } else if file_type.is_dir() {
             oio::Entry::new(
-                &rel_path,
-                Metadata::new(EntryMode::FILE).with_content_length(de_metadata.len()),
+                &format!("{rel_path}/"),
+                Metadata::builder(EntryMode::DIR).build(),
             )
-        } else if file_type.is_dir() {
-            oio::Entry::new(&format!("{rel_path}/"), Metadata::new(EntryMode::DIR))
         } else {
-            oio::Entry::new(&rel_path, Metadata::new(EntryMode::Unknown))
+            oio::Entry::new(&rel_path, Metadata::builder(EntryMode::Unknown).build())
         };
 
         return Ok(Some(entry));
@@ -90,7 +94,7 @@ impl oio::List for CompfsLister {
         if let Some(root) = self.root.take() {
             return Ok(Some(oio::Entry::new(
                 &format!("{root}/"),
-                Metadata::new(EntryMode::DIR),
+                Metadata::builder(EntryMode::DIR).build(),
             )));
         }
         let Some(mut read_dir) = self.read_dir.take() else {
diff --git a/core/services/compfs/src/writer.rs b/core/services/compfs/src/writer.rs
index 87e9f2d783..78a3e5f256 100644
--- a/core/services/compfs/src/writer.rs
+++ b/core/services/compfs/src/writer.rs
@@ -72,7 +72,7 @@ impl oio::Write for CompfsWriter {
             })
             .await?;
 
-        Ok(Metadata::default())
+        Ok(Metadata::builder(EntryMode::Unknown).build())
     }
 
     async fn abort(&mut self) -> Result<()> {
diff --git a/core/services/cos/src/backend.rs b/core/services/cos/src/backend.rs
index 615995eb3c..222e7b33c4 100644
--- a/core/services/cos/src/backend.rs
+++ b/core/services/cos/src/backend.rs
@@ -336,20 +336,20 @@ impl Service for CosBackend {
         match status {
             StatusCode::OK => {
                 let headers = resp.headers();
-                let mut meta = parse_into_metadata(path, headers)?;
+                let mut meta = parse_into_metadata(path, headers)?.into_builder();
 
                 let user_meta = parse_prefixed_headers(headers, "x-cos-meta-");
                 if !user_meta.is_empty() {
-                    meta = meta.with_user_metadata(user_meta);
+                    meta.user_metadata(user_meta);
                 }
 
                 if let Some(v) = parse_header_to_str(headers, constants::X_COS_VERSION_ID)?
                     && v != "null"
                 {
-                    meta.set_version(v);
+                    meta.version(v);
                 }
 
-                Ok(RpStat::new(meta))
+                Ok(RpStat::new(meta.build()))
             }
             _ => Err(parse_error(
                 ErrorContext::new(ServiceOperation("HeadObject")),
@@ -443,7 +443,7 @@ impl Service for CosBackend {
             let status = resp.status();
 
             match status {
-                StatusCode::OK => Ok(Metadata::default()),
+                StatusCode::OK => Ok(Metadata::builder(EntryMode::Unknown).build()),
                 _ => Err(parse_error(
                     ErrorContext::new(ServiceOperation("CopyObject")),
                     resp,
diff --git a/core/services/cos/src/lister.rs b/core/services/cos/src/lister.rs
index 940bad92ad..e60498b3d8 100644
--- a/core/services/cos/src/lister.rs
+++ b/core/services/cos/src/lister.rs
@@ -96,7 +96,7 @@ impl oio::PageList for CosLister {
         for prefix in output.common_prefixes {
             let de = oio::Entry::new(
                 &build_rel_path(&self.core.root, &prefix.prefix),
-                Metadata::new(EntryMode::DIR),
+                Metadata::builder(EntryMode::DIR).build(),
             );
 
             ctx.entries.push_back(de);
@@ -108,15 +108,15 @@ impl oio::PageList for CosLister {
                 path = "/".to_string();
             }
 
-            let mut meta =
-                Metadata::new(EntryMode::from_path(&path)).with_content_length(object.size);
-            meta.set_last_modified(object.last_modified.parse::<Timestamp>()?);
+            let mut meta = Metadata::builder(EntryMode::from_path(&path));
+            meta.content_length(object.size);
+            meta.last_modified(object.last_modified.parse::<Timestamp>()?);
             if let Some(etag) = object.etag {
-                meta.set_etag(&etag);
-                meta.set_content_md5(etag.trim_matches('"'));
+                meta.etag(&etag);
+                meta.content_md5(etag.trim_matches('"'));
             }
 
-            let de = oio::Entry::with(path, meta);
+            let de = oio::Entry::with(path, meta.build());
             ctx.entries.push_back(de);
         }
 
@@ -207,7 +207,7 @@ impl oio::PageList for CosObjectVersionsLister {
         for prefix in output.common_prefixes {
             let de = oio::Entry::new(
                 &build_rel_path(&self.core.root, &prefix.prefix),
-                Metadata::new(EntryMode::DIR),
+                Metadata::builder(EntryMode::DIR).build(),
             );
             ctx.entries.push_back(de);
         }
@@ -226,17 +226,17 @@ impl oio::PageList for CosObjectVersionsLister {
                 path = "/".to_owned();
             }
 
-            let mut meta = Metadata::new(EntryMode::from_path(&path));
-            meta.set_version(&version_object.version_id);
-            meta.set_is_current(version_object.is_latest);
-            meta.set_content_length(version_object.size);
-            meta.set_last_modified(version_object.last_modified.parse::<Timestamp>()?);
+            let mut meta = Metadata::builder(EntryMode::from_path(&path));
+            meta.version(&version_object.version_id);
+            meta.is_current(Some(version_object.is_latest));
+            meta.content_length(version_object.size);
+            meta.last_modified(version_object.last_modified.parse::<Timestamp>()?);
             if let Some(etag) = version_object.etag {
-                meta.set_etag(&etag);
-                meta.set_content_md5(etag.trim_matches('"'));
+                meta.etag(&etag);
+                meta.content_md5(etag.trim_matches('"'));
             }
 
-            let entry = oio::Entry::new(&path, meta);
+            let entry = oio::Entry::new(&path, meta.build());
             ctx.entries.push_back(entry);
         }
 
@@ -247,13 +247,13 @@ impl oio::PageList for CosObjectVersionsLister {
                     path = "/".to_owned();
                 }
 
-                let mut meta = Metadata::new(EntryMode::FILE);
-                meta.set_version(&delete_marker.version_id);
-                meta.set_is_deleted(true);
-                meta.set_is_current(delete_marker.is_latest);
-                meta.set_last_modified(delete_marker.last_modified.parse::<Timestamp>()?);
+                let mut meta = Metadata::builder(EntryMode::FILE);
+                meta.version(&delete_marker.version_id);
+                meta.is_deleted(true);
+                meta.is_current(Some(delete_marker.is_latest));
+                meta.last_modified(delete_marker.last_modified.parse::<Timestamp>()?);
 
-                let entry = oio::Entry::new(&path, meta);
+                let entry = oio::Entry::new(&path, meta.build());
                 ctx.entries.push_back(entry);
             }
         }
diff --git a/core/services/cos/src/writer.rs b/core/services/cos/src/writer.rs
index fdee655ffb..6d5ff24bbd 100644
--- a/core/services/cos/src/writer.rs
+++ b/core/services/cos/src/writer.rs
@@ -25,6 +25,7 @@ use http::StatusCode;
 use super::core::parse_error;
 use super::core::*;
 use opendal_core::Buffer;
+use opendal_core::EntryMode;
 use opendal_core::Error;
 use opendal_core::ErrorKind;
 use opendal_core::Metadata;
@@ -53,20 +54,20 @@ impl CosWriter {
     }
 
     fn parse_metadata(headers: &HeaderMap<HeaderValue>) -> Result<Metadata> {
-        let mut meta = Metadata::default();
+        let mut meta = Metadata::builder(EntryMode::Unknown);
         if let Some(etag) = parse_etag(headers)? {
-            meta.set_etag(etag);
+            meta.etag(etag);
         }
         if let Some(md5) = parse_content_md5(headers)? {
-            meta.set_content_md5(md5);
+            meta.content_md5(md5);
         }
         if let Some(version) = parse_header_to_str(headers, constants::X_COS_VERSION_ID)?
             && version != "null"
         {
-            meta.set_version(version);
+            meta.version(version);
         }
 
-        Ok(meta)
+        Ok(meta.build())
     }
 }
 
@@ -178,17 +179,17 @@ impl oio::MultipartWrite for CosWriter {
             .cos_complete_multipart_upload(&self.ctx, &self.path, upload_id, parts, &self.op)
             .await?;
 
-        let mut meta = Self::parse_metadata(resp.headers())?;
+        let mut meta = Self::parse_metadata(resp.headers())?.into_builder();
 
         let result: CompleteMultipartUploadResult =
             quick_xml::de::from_reader(resp.body_mut().reader())
                 .map_err(new_xml_deserialize_error)?;
-        meta.set_etag(&result.etag);
+        meta.etag(&result.etag);
 
         let status = resp.status();
 
         match status {
-            StatusCode::OK => Ok(meta),
+            StatusCode::OK => Ok(meta.build()),
             _ => Err(parse_error(
                 ErrorContext::new(ServiceOperation("CompleteMultipartUpload")),
                 resp,
diff --git a/core/services/d1/src/backend.rs b/core/services/d1/src/backend.rs
index fd6f1fa5ab..d1f158fdc1 100644
--- a/core/services/d1/src/backend.rs
+++ b/core/services/d1/src/backend.rs
@@ -247,12 +247,14 @@ impl Service for D1Backend {
         let p = build_abs_path(&self.root, path);
 
         if p == build_abs_path(&self.root, "") {
-            Ok(RpStat::new(Metadata::new(EntryMode::DIR)))
+            Ok(RpStat::new(Metadata::builder(EntryMode::DIR).build()))
         } else {
             match self.core.get_length(ctx, &p).await? {
-                Some(length) => Ok(RpStat::new(
-                    Metadata::new(EntryMode::FILE).with_content_length(length as u64),
-                )),
+                Some(length) => Ok(RpStat::new({
+                    let mut metadata = Metadata::builder(EntryMode::FILE);
+                    metadata.content_length(length as u64);
+                    metadata.build()
+                })),
                 None => Err(Error::new(ErrorKind::NotFound, "kv not found in d1")),
             }
         }
diff --git a/core/services/d1/src/reader.rs b/core/services/d1/src/reader.rs
index 136db8fed3..e03c8083d1 100644
--- a/core/services/d1/src/reader.rs
+++ b/core/services/d1/src/reader.rs
@@ -48,7 +48,11 @@ impl oio::StreamRead for D1Reader {
             }
         };
         let content = bs.slice(range.to_content_range(bs.len())?);
-        let metadata = Metadata::new(EntryMode::FILE).with_content_length(bs.len() as u64);
+        let metadata = {
+            let mut metadata = Metadata::builder(EntryMode::FILE);
+            metadata.content_length(bs.len() as u64);
+            metadata.build()
+        };
         Ok((
             RpRead::new(metadata),
             Box::new(content) as Box<dyn oio::ReadStreamDyn>,
diff --git a/core/services/d1/src/writer.rs b/core/services/d1/src/writer.rs
index d5b7de861f..669d31ce3d 100644
--- a/core/services/d1/src/writer.rs
+++ b/core/services/d1/src/writer.rs
@@ -50,7 +50,11 @@ impl oio::Write for D1Writer {
         let length = buf.len() as u64;
         self.core.set(&self.ctx, &self.path, buf).await?;
 
-        let meta = Metadata::new(EntryMode::from_path(&self.path)).with_content_length(length);
+        let meta = {
+            let mut metadata = Metadata::builder(EntryMode::from_path(&self.path));
+            metadata.content_length(length);
+            metadata.build()
+        };
         Ok(meta)
     }
 
diff --git a/core/services/dashmap/src/backend.rs b/core/services/dashmap/src/backend.rs
index d2144b82fa..67f3e33e70 100644
--- a/core/services/dashmap/src/backend.rs
+++ b/core/services/dashmap/src/backend.rs
@@ -149,7 +149,7 @@ impl Service for DashmapBackend {
                 if p.ends_with('/') {
                     let has_children = self.core.cache.iter().any(|kv| kv.key().starts_with(&p));
                     if has_children {
-                        return Ok(RpStat::new(Metadata::new(EntryMode::DIR)));
+                        return Ok(RpStat::new(Metadata::builder(EntryMode::DIR).build()));
                     }
                 }
                 Err(Error::new(ErrorKind::NotFound, "key not found in dashmap"))
diff --git a/core/services/dashmap/src/reader.rs b/core/services/dashmap/src/reader.rs
index 9df43a9701..a0e7f365b1 100644
--- a/core/services/dashmap/src/reader.rs
+++ b/core/services/dashmap/src/reader.rs
@@ -46,7 +46,11 @@ impl oio::StreamRead for DashmapReader {
                 let buffer = value
                     .content
                     .slice(range.to_content_range(value.content.len())?);
-                let metadata = Metadata::new(EntryMode::FILE).with_content_length(total_size);
+                let metadata = {
+                    let mut metadata = Metadata::builder(EntryMode::FILE);
+                    metadata.content_length(total_size);
+                    metadata.build()
+                };
                 Ok((
                     RpRead::new(metadata),
                     Box::new(buffer) as Box<dyn oio::ReadStreamDyn>,
diff --git a/core/services/dashmap/src/writer.rs b/core/services/dashmap/src/writer.rs
index 36517238a7..3434810823 100644
--- a/core/services/dashmap/src/writer.rs
+++ b/core/services/dashmap/src/writer.rs
@@ -51,23 +51,24 @@ impl oio::Write for DashmapWriter {
         let content = self.buf.clone().collect();
 
         let entry_mode = EntryMode::from_path(&self.path);
-        let mut meta = Metadata::new(entry_mode);
-        meta.set_content_length(content.len() as u64);
-        meta.set_last_modified(Timestamp::now());
+        let mut meta = Metadata::builder(entry_mode);
+        meta.content_length(content.len() as u64);
+        meta.last_modified(Timestamp::now());
 
         if let Some(v) = self.op.content_type() {
-            meta.set_content_type(v);
+            meta.content_type(v);
         }
         if let Some(v) = self.op.content_disposition() {
-            meta.set_content_disposition(v);
+            meta.content_disposition(v);
         }
         if let Some(v) = self.op.cache_control() {
-            meta.set_cache_control(v);
+            meta.cache_control(v);
         }
         if let Some(v) = self.op.content_encoding() {
-            meta.set_content_encoding(v);
+            meta.content_encoding(v);
         }
 
+        let meta = meta.build();
         self.core.set(
             &self.path,
             DashmapValue {
diff --git a/core/services/dbfs/src/backend.rs b/core/services/dbfs/src/backend.rs
index 3bb53ab0df..8c88f22204 100644
--- a/core/services/dbfs/src/backend.rs
+++ b/core/services/dbfs/src/backend.rs
@@ -175,7 +175,7 @@ impl Service for DbfsBackend {
     async fn stat(&self, ctx: &OperationContext, path: &str, _: OpStat) -> Result<RpStat> {
         // Stat root always returns a DIR.
         if path == "/" {
-            return Ok(RpStat::new(Metadata::new(EntryMode::DIR)));
+            return Ok(RpStat::new(Metadata::builder(EntryMode::DIR).build()));
         }
 
         let resp = self.core.dbfs_get_status(ctx, path).await?;
@@ -184,24 +184,24 @@ impl Service for DbfsBackend {
 
         match status {
             StatusCode::OK => {
-                let mut meta = parse_into_metadata(path, resp.headers())?;
+                let mut meta = parse_into_metadata(path, resp.headers())?.into_builder();
                 let bs = resp.into_body();
                 let decoded_response: DbfsStatus =
                     serde_json::from_reader(bs.reader()).map_err(new_json_deserialize_error)?;
-                meta.set_last_modified(Timestamp::from_millisecond(
+                meta.last_modified(Timestamp::from_millisecond(
                     decoded_response.modification_time,
                 )?);
                 match decoded_response.is_dir {
-                    true => meta.set_mode(EntryMode::DIR),
+                    true => meta.mode(EntryMode::DIR),
                     false => {
-                        meta.set_mode(EntryMode::FILE);
-                        meta.set_content_length(decoded_response.file_size as u64)
+                        meta.mode(EntryMode::FILE);
+                        meta.content_length(decoded_response.file_size as u64)
                     }
                 };
-                Ok(RpStat::new(meta))
+                Ok(RpStat::new(meta.build()))
             }
             StatusCode::NOT_FOUND if path.ends_with('/') => {
-                Ok(RpStat::new(Metadata::new(EntryMode::DIR)))
+                Ok(RpStat::new(Metadata::builder(EntryMode::DIR).build()))
             }
             _ => Err(parse_error(
                 ErrorContext::new(ServiceOperation("GetStatus")),
diff --git a/core/services/dbfs/src/lister.rs b/core/services/dbfs/src/lister.rs
index 1a66445bc6..fa4c69fce3 100644
--- a/core/services/dbfs/src/lister.rs
+++ b/core/services/dbfs/src/lister.rs
@@ -63,15 +63,15 @@ impl oio::PageList for DbfsLister {
             let entry: oio::Entry = match status.is_dir {
                 true => {
                     let normalized_path = format!("{path}/");
-                    let mut meta = Metadata::new(EntryMode::DIR);
-                    meta.set_last_modified(Timestamp::from_millisecond(status.modification_time)?);
-                    oio::Entry::new(&normalized_path, meta)
+                    let mut meta = Metadata::builder(EntryMode::DIR);
+                    meta.last_modified(Timestamp::from_millisecond(status.modification_time)?);
+                    oio::Entry::new(&normalized_path, meta.build())
                 }
                 false => {
-                    let mut meta = Metadata::new(EntryMode::FILE);
-                    meta.set_last_modified(Timestamp::from_millisecond(status.modification_time)?);
-                    meta.set_content_length(status.file_size as u64);
-                    oio::Entry::new(&path, meta)
+                    let mut meta = Metadata::builder(EntryMode::FILE);
+                    meta.last_modified(Timestamp::from_millisecond(status.modification_time)?);
+                    meta.content_length(status.file_size as u64);
+                    oio::Entry::new(&path, meta.build())
                 }
             };
             ctx.entries.push_back(entry);
diff --git a/core/services/dbfs/src/writer.rs b/core/services/dbfs/src/writer.rs
index 7aba69bd94..b295652d29 100644
--- a/core/services/dbfs/src/writer.rs
+++ b/core/services/dbfs/src/writer.rs
@@ -58,7 +58,9 @@ impl oio::OneShotWrite for DbfsWriter {
 
         let status = resp.status();
         match status {
-            StatusCode::CREATED | StatusCode::OK => Ok(Metadata::default()),
+            StatusCode::CREATED | StatusCode::OK => {
+                Ok(Metadata::builder(EntryMode::Unknown).build())
+            }
             _ => Err(parse_error(
                 ErrorContext::new(ServiceOperation("Put")),
                 resp,
diff --git a/core/services/dropbox/src/backend.rs b/core/services/dropbox/src/backend.rs
index 7dc3a64145..0ed43ce56a 100644
--- a/core/services/dropbox/src/backend.rs
+++ b/core/services/dropbox/src/backend.rs
@@ -250,17 +250,17 @@ impl Service for DropboxBackend {
                     _ => EntryMode::Unknown,
                 };
 
-                let mut metadata = Metadata::new(entry_mode);
+                let mut metadata = Metadata::builder(entry_mode);
                 // Only set last_modified and size if entry_mode is FILE, because Dropbox API
                 // returns last_modified and size only for files.
                 // FYI: https://www.dropbox.com/developers/documentation/http/documentation#files-get_metadata
                 if entry_mode == EntryMode::FILE {
                     let date_utc_last_modified =
                         decoded_response.client_modified.parse::<Timestamp>()?;
-                    metadata.set_last_modified(date_utc_last_modified);
+                    metadata.last_modified(date_utc_last_modified);
 
                     if let Some(size) = decoded_response.size {
-                        metadata.set_content_length(size);
+                        metadata.content_length(size);
                     } else {
                         return Err(Error::new(
                             ErrorKind::Unexpected,
@@ -268,7 +268,7 @@ impl Service for DropboxBackend {
                         ));
                     }
                 }
-                Ok(RpStat::new(metadata))
+                Ok(RpStat::new(metadata.build()))
             }
             _ => Err(parse_error(
                 ErrorContext::new(ServiceOperation("GetMetadata")),
@@ -344,11 +344,11 @@ impl Service for DropboxBackend {
             let status = resp.status();
 
             match status {
-                StatusCode::OK => Ok(Metadata::default()),
+                StatusCode::OK => Ok(Metadata::builder(EntryMode::Unknown).build()),
                 _ => {
                     let err = parse_error(ErrorContext::new(ServiceOperation("CopyFile")), resp);
                     match err.kind() {
-                        ErrorKind::NotFound => Ok(Metadata::default()),
+                        ErrorKind::NotFound => Ok(Metadata::builder(EntryMode::Unknown).build()),
                         _ => Err(err),
                     }
                 }
diff --git a/core/services/dropbox/src/lister.rs b/core/services/dropbox/src/lister.rs
index 932d5d9ce0..9ad0261b0b 100644
--- a/core/services/dropbox/src/lister.rs
+++ b/core/services/dropbox/src/lister.rs
@@ -98,7 +98,7 @@ impl oio::PageList for DropboxLister {
             };
 
             let mut name = entry.name;
-            let mut meta = Metadata::new(entry_mode);
+            let mut meta = Metadata::builder(entry_mode);
 
             // Dropbox will return folder names that do not end with '/'.
             if entry_mode == EntryMode::DIR && !name.ends_with('/') {
@@ -108,14 +108,14 @@ impl oio::PageList for DropboxLister {
             // The behavior here aligns with Dropbox's stat function.
             if entry_mode == EntryMode::FILE {
                 let date_utc_last_modified = entry.client_modified.parse::<Timestamp>()?;
-                meta.set_last_modified(date_utc_last_modified);
+                meta.last_modified(date_utc_last_modified);
 
                 if let Some(size) = entry.size {
-                    meta.set_content_length(size);
+                    meta.content_length(size);
                 }
             }
 
-            ctx.entries.push_back(oio::Entry::with(name, meta));
+            ctx.entries.push_back(oio::Entry::with(name, meta.build()));
         }
 
         if decoded_response.has_more {
diff --git a/core/services/dropbox/src/writer.rs b/core/services/dropbox/src/writer.rs
index 343875cec0..06394bbab0 100644
--- a/core/services/dropbox/src/writer.rs
+++ b/core/services/dropbox/src/writer.rs
@@ -43,29 +43,29 @@ impl DropboxWriter {
     }
 
     fn parse_metadata(decoded_response: DropboxMetadataResponse) -> Result<Metadata> {
-        let mut metadata = Metadata::default();
+        let mut metadata = Metadata::builder(EntryMode::Unknown);
 
         if let Some(size) = decoded_response.size {
-            metadata.set_content_length(size);
+            metadata.content_length(size);
         }
 
         if let Some(content_hash) = decoded_response.content_hash {
-            metadata.set_etag(&content_hash);
+            metadata.etag(&content_hash);
         }
 
         if let Some(rev) = decoded_response.rev {
-            metadata.set_version(&rev);
+            metadata.version(&rev);
         }
 
         if let Some(server_modified) = decoded_response.server_modified {
             let date_utc = server_modified.parse::<Timestamp>()?;
-            metadata.set_last_modified(date_utc);
+            metadata.last_modified(date_utc);
         } else {
             let date_utc = decoded_response.client_modified.parse::<Timestamp>()?;
-            metadata.set_last_modified(date_utc);
+            metadata.last_modified(date_utc);
         }
 
-        Ok(metadata)
+        Ok(metadata.build())
     }
 }
 
diff --git a/core/services/etcd/src/backend.rs b/core/services/etcd/src/backend.rs
index 6d09d7136e..3afbf71ec8 100644
--- a/core/services/etcd/src/backend.rs
+++ b/core/services/etcd/src/backend.rs
@@ -246,9 +246,9 @@ impl Service for EtcdBackend {
         // First check if it's a direct key
         match self.core.get(&abs_path).await? {
             Some(buffer) => {
-                let mut metadata = Metadata::new(EntryMode::from_path(&abs_path));
-                metadata.set_content_length(buffer.len() as u64);
-                Ok(RpStat::new(metadata))
+                let mut metadata = Metadata::builder(EntryMode::from_path(&abs_path));
+                metadata.content_length(buffer.len() as u64);
+                Ok(RpStat::new(metadata.build()))
             }
             None => {
                 // Check if it's a directory by looking for keys with this prefix
@@ -262,7 +262,7 @@ impl Service for EtcdBackend {
                 let has_children = self.core.has_prefix(&prefix).await?;
                 if has_children {
                     // Has children, it's a directory
-                    let metadata = Metadata::new(EntryMode::DIR);
+                    let metadata = Metadata::builder(EntryMode::DIR).build();
                     Ok(RpStat::new(metadata))
                 } else {
                     Err(Error::new(ErrorKind::NotFound, "path not found"))
diff --git a/core/services/etcd/src/lister.rs b/core/services/etcd/src/lister.rs
index c7506330bd..0f03b43a63 100644
--- a/core/services/etcd/src/lister.rs
+++ b/core/services/etcd/src/lister.rs
@@ -69,7 +69,8 @@ impl oio::List for EtcdLister {
             if key.starts_with(&self.path) {
                 let path = build_rel_path(&self.root, &key);
 
-                let entry = Entry::new(&path, Metadata::new(EntryMode::from_path(&key)));
+                let entry =
+                    Entry::new(&path, Metadata::builder(EntryMode::from_path(&key)).build());
                 return Ok(Some(entry));
             }
         }
diff --git a/core/services/etcd/src/reader.rs b/core/services/etcd/src/reader.rs
index fc3c500a38..46db5a879b 100644
--- a/core/services/etcd/src/reader.rs
+++ b/core/services/etcd/src/reader.rs
@@ -44,7 +44,11 @@ impl oio::StreamRead for EtcdReader {
             Some(buffer) => {
                 let total_size = buffer.len() as u64;
                 let sliced_buffer = buffer.slice(range.to_content_range(buffer.len())?);
-                let metadata = Metadata::new(EntryMode::FILE).with_content_length(total_size);
+                let metadata = {
+                    let mut metadata = Metadata::builder(EntryMode::FILE);
+                    metadata.content_length(total_size);
+                    metadata.build()
+                };
 
                 Ok((
                     RpRead::new(metadata),
diff --git a/core/services/etcd/src/writer.rs b/core/services/etcd/src/writer.rs
index 7ab5714bde..10160093dd 100644
--- a/core/services/etcd/src/writer.rs
+++ b/core/services/etcd/src/writer.rs
@@ -48,10 +48,10 @@ impl oio::Write for EtcdWriter {
 
         self.core.set(&self.path, buf.clone()).await?;
 
-        let mut metadata = Metadata::new(EntryMode::from_path(&self.path));
-        metadata.set_content_length(buf.len() as u64);
+        let mut metadata = Metadata::builder(EntryMode::from_path(&self.path));
+        metadata.content_length(buf.len() as u64);
 
-        Ok(metadata)
+        Ok(metadata.build())
     }
 
     async fn abort(&mut self) -> Result<()> {
diff --git a/core/services/foundationdb/src/backend.rs b/core/services/foundationdb/src/backend.rs
index efe4b956e7..8cd9f0fd62 100644
--- a/core/services/foundationdb/src/backend.rs
+++ b/core/services/foundationdb/src/backend.rs
@@ -151,13 +151,15 @@ impl Service for FoundationdbBackend {
         let p = build_abs_path(&self.root, path);
 
         if p == build_abs_path(&self.root, "") {
-            Ok(RpStat::new(Metadata::new(EntryMode::DIR)))
+            Ok(RpStat::new(Metadata::builder(EntryMode::DIR).build()))
         } else {
             let bs = self.core.get(&p).await?;
             match bs {
-                Some(bs) => Ok(RpStat::new(
-                    Metadata::new(EntryMode::FILE).with_content_length(bs.len() as u64),
-                )),
+                Some(bs) => Ok(RpStat::new({
+                    let mut metadata = Metadata::builder(EntryMode::FILE);
+                    metadata.content_length(bs.len() as u64);
+                    metadata.build()
+                })),
                 None => Err(Error::new(
                     ErrorKind::NotFound,
                     "kv not found in foundationdb",
diff --git a/core/services/foundationdb/src/reader.rs b/core/services/foundationdb/src/reader.rs
index e70a4d8c44..f9cb207015 100644
--- a/core/services/foundationdb/src/reader.rs
+++ b/core/services/foundationdb/src/reader.rs
@@ -49,7 +49,11 @@ impl oio::StreamRead for FoundationdbReader {
             }
         };
         let content = bs.slice(range.to_content_range(bs.len())?);
-        let metadata = Metadata::new(EntryMode::FILE).with_content_length(bs.len() as u64);
+        let metadata = {
+            let mut metadata = Metadata::builder(EntryMode::FILE);
+            metadata.content_length(bs.len() as u64);
+            metadata.build()
+        };
         Ok((
             RpRead::new(metadata),
             Box::new(content) as Box<dyn oio::ReadStreamDyn>,
diff --git a/core/services/foundationdb/src/writer.rs b/core/services/foundationdb/src/writer.rs
index 81ca5ee996..1383435798 100644
--- a/core/services/foundationdb/src/writer.rs
+++ b/core/services/foundationdb/src/writer.rs
@@ -48,7 +48,11 @@ impl oio::Write for FoundationdbWriter {
         let length = buf.len() as u64;
         self.core.set(&self.path, buf).await?;
 
-        let meta = Metadata::new(EntryMode::from_path(&self.path)).with_content_length(length);
+        let meta = {
+            let mut metadata = Metadata::builder(EntryMode::from_path(&self.path));
+            metadata.content_length(length);
+            metadata.build()
+        };
         Ok(meta)
     }
 
diff --git a/core/services/foyer/src/backend.rs b/core/services/foyer/src/backend.rs
index e1865f0c0e..63587a3904 100644
--- a/core/services/foyer/src/backend.rs
+++ b/core/services/foyer/src/backend.rs
@@ -270,12 +270,14 @@ impl Service for FoyerBackend {
         let p = build_abs_path(&self.root, path);
 
         if p == build_abs_path(&self.root, "") {
-            Ok(RpStat::new(Metadata::new(EntryMode::DIR)))
+            Ok(RpStat::new(Metadata::builder(EntryMode::DIR).build()))
         } else {
             match self.core.get(&p).await? {
-                Some(bs) => Ok(RpStat::new(
-                    Metadata::new(EntryMode::FILE).with_content_length(bs.len() as u64),
-                )),
+                Some(bs) => Ok(RpStat::new({
+                    let mut metadata = Metadata::builder(EntryMode::FILE);
+                    metadata.content_length(bs.len() as u64);
+                    metadata.build()
+                })),
                 None => Err(Error::new(ErrorKind::NotFound, "key not found in foyer")),
             }
         }
diff --git a/core/services/foyer/src/reader.rs b/core/services/foyer/src/reader.rs
index 2dc5cb0511..452b06e955 100644
--- a/core/services/foyer/src/reader.rs
+++ b/core/services/foyer/src/reader.rs
@@ -48,7 +48,11 @@ impl oio::StreamRead for FoyerReader {
 
         let buffer = buffer.slice(range.to_content_range(buffer.len())?);
 
-        let metadata = Metadata::new(EntryMode::FILE).with_content_length(content_length);
+        let metadata = {
+            let mut metadata = Metadata::builder(EntryMode::FILE);
+            metadata.content_length(content_length);
+            metadata.build()
+        };
         Ok((
             RpRead::new(metadata),
             Box::new(buffer) as Box<dyn oio::ReadStreamDyn>,
diff --git a/core/services/foyer/src/writer.rs b/core/services/foyer/src/writer.rs
index e9faa0230f..3be2928b91 100644
--- a/core/services/foyer/src/writer.rs
+++ b/core/services/foyer/src/writer.rs
@@ -49,7 +49,11 @@ impl oio::Write for FoyerWriter {
         let length = buf.len() as u64;
         self.core.insert(&self.path, buf).await?;
 
-        let meta = Metadata::new(EntryMode::from_path(&self.path)).with_content_length(length);
+        let meta = {
+            let mut metadata = Metadata::builder(EntryMode::from_path(&self.path));
+            metadata.content_length(length);
+            metadata.build()
+        };
         Ok(meta)
     }
 
diff --git a/core/services/fs/src/backend.rs b/core/services/fs/src/backend.rs
index 49f9b353a0..906484ca2f 100644
--- a/core/services/fs/src/backend.rs
+++ b/core/services/fs/src/backend.rs
@@ -240,7 +240,7 @@ impl Service for FsBackend {
         let to = to.to_string();
         Ok(oio::OneShotCopier::new(async move {
             core.fs_copy(&from, &to).await?;
-            Ok(Metadata::default())
+            Ok(Metadata::builder(EntryMode::Unknown).build())
         }))
     }
 
diff --git a/core/services/fs/src/core.rs b/core/services/fs/src/core.rs
index 0be1604ffb..848f6c0ea4 100644
--- a/core/services/fs/src/core.rs
+++ b/core/services/fs/src/core.rs
@@ -110,9 +110,9 @@ impl FsCore {
         } else {
             EntryMode::Unknown
         };
-        let mut m = Metadata::new(mode)
-            .with_content_length(meta.len())
-            .with_last_modified(Timestamp::try_from(
+        let mut m = Metadata::builder(mode);
+        m.content_length(meta.len())
+            .last_modified(Timestamp::try_from(
                 meta.modified().map_err(new_std_io_error)?,
             )?);
 
@@ -121,11 +121,11 @@ impl FsCore {
         {
             let user_metadata = Self::get_user_metadata(&p)?;
             if !user_metadata.is_empty() {
-                m = m.with_user_metadata(user_metadata);
+                m.user_metadata(user_metadata);
             }
         }
 
-        Ok(m)
+        Ok(m.build())
     }
 
     pub async fn fs_open(&self, path: &str) -> Result<File> {
diff --git a/core/services/fs/src/lister.rs b/core/services/fs/src/lister.rs
index a6c2d1c3a2..980105ee0c 100644
--- a/core/services/fs/src/lister.rs
+++ b/core/services/fs/src/lister.rs
@@ -51,7 +51,7 @@ impl oio::List for FsLister<tokio::fs::ReadDir> {
         loop {
             // since list should return path itself, we return it first
             if let Some(path) = self.current_path.take() {
-                let e = oio::Entry::new(path.as_str(), Metadata::new(EntryMode::DIR));
+                let e = oio::Entry::new(path.as_str(), Metadata::builder(EntryMode::DIR).build());
                 return Ok(Some(e));
             }
 
@@ -106,11 +106,12 @@ impl oio::List for FsLister<tokio::fs::ReadDir> {
                 }
                 Err(e) => return Err(new_std_io_error(e)),
             };
-            let metadata = Metadata::new(mode)
-                .with_content_length(de_metadata.len())
-                .with_last_modified(Timestamp::try_from(last_modified)?);
+            let mut metadata = Metadata::builder(mode);
+            metadata
+                .content_length(de_metadata.len())
+                .last_modified(Timestamp::try_from(last_modified)?);
 
-            return Ok(Some(oio::Entry::new(path, metadata)));
+            return Ok(Some(oio::Entry::new(path, metadata.build())));
         }
     }
 }
diff --git a/core/services/fs/src/writer.rs b/core/services/fs/src/writer.rs
index d2d360cb1c..61879e7915 100644
--- a/core/services/fs/src/writer.rs
+++ b/core/services/fs/src/writer.rs
@@ -46,7 +46,12 @@ impl FsWriter {
 
         // Store user metadata for later use on Unix systems.
         #[cfg(unix)]
-        let user_metadata = op.user_metadata().cloned();
+        let user_metadata = op.user_metadata().map(|metadata| {
+            metadata
+                .into_iter()
+                .map(|(key, value)| (key.to_owned(), value.to_owned()))
+                .collect()
+        });
 
         // Quick path while atomic_write_dir is not set.
         if core.atomic_write_dir.is_none() {
@@ -123,12 +128,12 @@ impl oio::Write for FsWriter {
         }
 
         let file_meta = self.f.metadata().await.map_err(new_std_io_error)?;
-        let meta = Metadata::new(EntryMode::FILE)
-            .with_content_length(file_meta.len())
-            .with_last_modified(Timestamp::try_from(
+        let mut meta = Metadata::builder(EntryMode::FILE);
+        meta.content_length(file_meta.len())
+            .last_modified(Timestamp::try_from(
                 file_meta.modified().map_err(new_std_io_error)?,
             )?);
-        Ok(meta)
+        Ok(meta.build())
     }
 
     async fn abort(&mut self) -> Result<()> {
@@ -205,12 +210,12 @@ impl oio::PositionWrite for FsWriter {
         } else {
             EntryMode::Unknown
         };
-        let meta = Metadata::new(mode)
-            .with_content_length(file_meta.len())
-            .with_last_modified(Timestamp::try_from(
+        let mut meta = Metadata::builder(mode);
+        meta.content_length(file_meta.len())
+            .last_modified(Timestamp::try_from(
                 file_meta.modified().map_err(new_std_io_error)?,
             )?);
-        Ok(meta)
+        Ok(meta.build())
     }
 
     async fn abort(&self) -> Result<()> {
diff --git a/core/services/ftp/src/backend.rs b/core/services/ftp/src/backend.rs
index dc27f254b2..e649cd1d19 100644
--- a/core/services/ftp/src/backend.rs
+++ b/core/services/ftp/src/backend.rs
@@ -241,11 +241,11 @@ impl Service for FtpBackend {
             EntryMode::Unknown
         };
 
-        let mut meta = Metadata::new(mode);
-        meta.set_content_length(file.size() as u64);
-        meta.set_last_modified(Timestamp::try_from(file.modified())?);
+        let mut meta = Metadata::builder(mode);
+        meta.content_length(file.size() as u64);
+        meta.last_modified(Timestamp::try_from(file.modified())?);
 
-        Ok(RpStat::new(meta))
+        Ok(RpStat::new(meta.build()))
     }
     fn read(&self, _ctx: &OperationContext, path: &str, args: OpRead) -> Result<Self::Reader> {
         let output: oio::StreamReader<FtpReader> = {
diff --git a/core/services/ftp/src/lister.rs b/core/services/ftp/src/lister.rs
index a16b993a48..7c0c72dd9c 100644
--- a/core/services/ftp/src/lister.rs
+++ b/core/services/ftp/src/lister.rs
@@ -50,21 +50,21 @@ impl oio::List for FtpLister {
         let path = self.path.to_string() + de.name();
 
         let mut meta = if de.is_file() {
-            Metadata::new(EntryMode::FILE)
+            Metadata::builder(EntryMode::FILE)
         } else if de.is_directory() {
-            Metadata::new(EntryMode::DIR)
+            Metadata::builder(EntryMode::DIR)
         } else {
-            Metadata::new(EntryMode::Unknown)
+            Metadata::builder(EntryMode::Unknown)
         };
-        meta.set_content_length(de.size() as u64);
-        meta.set_last_modified(Timestamp::try_from(de.modified())?);
+        meta.content_length(de.size() as u64);
+        meta.last_modified(Timestamp::try_from(de.modified())?);
 
         let entry = if de.is_file() {
-            oio::Entry::new(&path, meta)
+            oio::Entry::new(&path, meta.build())
         } else if de.is_directory() {
-            oio::Entry::new(&format!("{}/", path), meta)
+            oio::Entry::new(&format!("{}/", path), meta.build())
         } else {
-            oio::Entry::new(&path, meta)
+            oio::Entry::new(&path, meta.build())
         };
 
         Ok(Some(entry))
diff --git a/core/services/ftp/src/reader.rs b/core/services/ftp/src/reader.rs
index 0555d858e9..3dc20654ef 100644
--- a/core/services/ftp/src/reader.rs
+++ b/core/services/ftp/src/reader.rs
@@ -164,7 +164,7 @@ impl oio::Write for FtpLazyWriter {
     async fn close(&mut self) -> Result<Metadata> {
         match &mut self.inner {
             Some(w) => w.close().await,
-            None => Ok(Metadata::default()),
+            None => Ok(Metadata::builder(EntryMode::Unknown).build()),
         }
     }
 
diff --git a/core/services/ftp/src/writer.rs b/core/services/ftp/src/writer.rs
index 4148045f79..da122c12d8 100644
--- a/core/services/ftp/src/writer.rs
+++ b/core/services/ftp/src/writer.rs
@@ -110,7 +110,7 @@ impl oio::Write for FtpWriter {
             }
         }
 
-        Ok(Metadata::default())
+        Ok(Metadata::builder(EntryMode::Unknown).build())
     }
 
     async fn abort(&mut self) -> Result<()> {
diff --git a/core/services/gcs-grpc/src/backend.rs b/core/services/gcs-grpc/src/backend.rs
index 9e6d0b3360..4659dc8893 100644
--- a/core/services/gcs-grpc/src/backend.rs
+++ b/core/services/gcs-grpc/src/backend.rs
@@ -329,7 +329,7 @@ impl Service for GcsGrpcBackend {
 
     async fn stat(&self, ctx: &OperationContext, path: &str, args: OpStat) -> Result<RpStat> {
         if path == "/" {
-            return Ok(RpStat::new(Metadata::new(EntryMode::DIR)));
+            return Ok(RpStat::new(Metadata::builder(EntryMode::DIR).build()));
         }
         let object = self.core.object_name(path);
         let request = GetObjectRequest {
diff --git a/core/services/gcs-grpc/src/core.rs b/core/services/gcs-grpc/src/core.rs
index 2e13843ce5..88ced42427 100644
--- a/core/services/gcs-grpc/src/core.rs
+++ b/core/services/gcs-grpc/src/core.rs
@@ -196,35 +196,35 @@ pub(crate) fn parse_object(object: &Object) -> Metadata {
     } else {
         EntryMode::FILE
     };
-    let mut metadata = Metadata::new(mode);
-    metadata.set_content_length(object.size.max(0) as u64);
+    let mut metadata = Metadata::builder(mode);
+    metadata.content_length(object.size.max(0) as u64);
     if !object.cache_control.is_empty() {
-        metadata.set_cache_control(&object.cache_control);
+        metadata.cache_control(&object.cache_control);
     }
     if !object.content_type.is_empty() {
-        metadata.set_content_type(&object.content_type);
+        metadata.content_type(&object.content_type);
     }
     if !object.content_encoding.is_empty() {
-        metadata.set_content_encoding(&object.content_encoding);
+        metadata.content_encoding(&object.content_encoding);
     }
     if !object.content_disposition.is_empty() {
-        metadata.set_content_disposition(&object.content_disposition);
+        metadata.content_disposition(&object.content_disposition);
     }
     if !object.etag.is_empty() {
-        metadata.set_etag(&object.etag);
+        metadata.etag(&object.etag);
     }
     if object.generation != 0 {
-        metadata.set_version(&object.generation.to_string());
+        metadata.version(object.generation.to_string());
     }
     if !object.metadata.is_empty() {
-        metadata = metadata.with_user_metadata(object.metadata.clone());
+        metadata.user_metadata(object.metadata.clone());
     }
     if let Some(ts) = object.update_time.as_ref().or(object.create_time.as_ref())
         && let Ok(ts) = Timestamp::new(ts.seconds, ts.nanos)
     {
-        metadata.set_last_modified(ts);
+        metadata.last_modified(ts);
     }
-    metadata
+    metadata.build()
 }
 
 #[cfg(test)]
diff --git a/core/services/gcs-grpc/src/lister.rs b/core/services/gcs-grpc/src/lister.rs
index 28795d0165..edd860c9fd 100644
--- a/core/services/gcs-grpc/src/lister.rs
+++ b/core/services/gcs-grpc/src/lister.rs
@@ -101,8 +101,10 @@ impl GcsGrpcLister {
                 continue;
             }
             let path = build_rel_path(&self.core.root, &prefix);
-            self.entries
-                .push_back(oio::Entry::with(path, Metadata::new(EntryMode::DIR)));
+            self.entries.push_back(oio::Entry::with(
+                path,
+                Metadata::builder(EntryMode::DIR).build(),
+            ));
         }
         Ok(())
     }
diff --git a/core/services/gcs-grpc/src/writer.rs b/core/services/gcs-grpc/src/writer.rs
index ae3c423ce5..e401c3fb73 100644
--- a/core/services/gcs-grpc/src/writer.rs
+++ b/core/services/gcs-grpc/src/writer.rs
@@ -87,7 +87,16 @@ impl GcsGrpcWriter {
                     .to_string(),
                 content_encoding: self.args.content_encoding().unwrap_or_default().to_string(),
                 cache_control: self.args.cache_control().unwrap_or_default().to_string(),
-                metadata: self.args.user_metadata().cloned().unwrap_or_default(),
+                metadata: self
+                    .args
+                    .user_metadata()
+                    .map(|metadata| {
+                        metadata
+                            .into_iter()
+                            .map(|(key, value)| (key.to_owned(), value.to_owned()))
+                            .collect()
+                    })
+                    .unwrap_or_default(),
                 ..Default::default()
             }),
             if_generation_match: self.args.if_not_exists().then_some(0),
diff --git a/core/services/gcs/src/copier.rs b/core/services/gcs/src/copier.rs
index 8d97658e65..eb4e69d335 100644
--- a/core/services/gcs/src/copier.rs
+++ b/core/services/gcs/src/copier.rs
@@ -161,7 +161,10 @@ impl oio::Copy for GcsCopier {
             self.next().await?;
         }
 
-        Ok(self.metadata.clone().unwrap_or_default())
+        Ok(self
+            .metadata
+            .clone()
+            .unwrap_or_else(|| Metadata::builder(EntryMode::Unknown).build()))
     }
 
     async fn abort(&mut self) -> Result<()> {
diff --git a/core/services/gcs/src/core.rs b/core/services/gcs/src/core.rs
index afe49d34a6..94424dc27d 100644
--- a/core/services/gcs/src/core.rs
+++ b/core/services/gcs/src/core.rs
@@ -949,45 +949,45 @@ impl GcsCore {
 
 impl GetObjectJsonResponse {
     fn into_metadata(self, path: &str) -> Result<Metadata> {
-        let mut m = Metadata::new(EntryMode::from_path(path));
+        let mut m = Metadata::builder(EntryMode::from_path(path));
 
-        m.set_etag(&self.etag);
-        m.set_content_md5(&self.md5_hash);
+        m.etag(&self.etag);
+        m.content_md5(&self.md5_hash);
 
         let size = self
             .size
             .parse::<u64>()
             .map_err(|e| Error::new(ErrorKind::Unexpected, "parse u64").set_source(e))?;
-        m.set_content_length(size);
+        m.content_length(size);
         if !self.content_type.is_empty() {
-            m.set_content_type(&self.content_type);
+            m.content_type(&self.content_type);
         }
 
         if !self.content_encoding.is_empty() {
-            m.set_content_encoding(&self.content_encoding);
+            m.content_encoding(&self.content_encoding);
         }
 
         if !self.cache_control.is_empty() {
-            m.set_cache_control(&self.cache_control);
+            m.cache_control(&self.cache_control);
         }
 
         if !self.content_disposition.is_empty() {
-            m.set_content_disposition(&self.content_disposition);
+            m.content_disposition(&self.content_disposition);
         }
 
         if !self.generation.is_empty() {
-            m.set_version(&self.generation);
+            m.version(&self.generation);
         }
 
         if !self.updated.is_empty() {
-            m.set_last_modified(self.updated.parse::<Timestamp>()?);
+            m.last_modified(self.updated.parse::<Timestamp>()?);
         }
 
         if !self.metadata.is_empty() {
-            m = m.with_user_metadata(self.metadata);
+            m.user_metadata(self.metadata);
         }
 
-        Ok(m)
+        Ok(m.build())
     }
 }
 
@@ -1016,7 +1016,7 @@ pub struct InsertRequestMetadata<'a> {
     #[serde(skip_serializing_if = "Option::is_none")]
     cache_control: Option<&'a str>,
     #[serde(skip_serializing_if = "Option::is_none")]
-    metadata: Option<&'a HashMap<String, String>>,
+    metadata: Option<UserMetadata<'a>>,
 }
 
 impl InsertRequestMetadata<'_> {
@@ -1096,7 +1096,7 @@ impl RewriteResponse {
     pub fn into_metadata(self, path: &str) -> Result<Metadata> {
         match self.resource {
             Some(resource) => resource.into_metadata(path),
-            None => Ok(Metadata::default()),
+            None => Ok(Metadata::builder(EntryMode::Unknown).build()),
         }
     }
 }
@@ -1170,6 +1170,20 @@ mod tests {
         }
     }
 
+    fn read_args(options: options::ReadOptions) -> OpRead {
+        let (_, args, _) = options.into();
+        args
+    }
+
+    fn write_args(options: options::WriteOptions) -> OpWrite {
+        let (args, _) = options.into();
+        args
+    }
+
+    fn copy_args(options: options::CopyOptions) -> OpCopy {
+        options.into()
+    }
+
     #[tokio::test]
     async fn test_insert_object_signing_preserves_wire_uri() {
         let core = test_core();
@@ -1206,7 +1220,10 @@ mod tests {
             .gcs_get_object_request(
                 "object",
                 BytesRange::default(),
-                &OpRead::default().with_if_version_match("123"),
+                &read_args(options::ReadOptions {
+                    if_version_match: Some("123".to_owned()),
+                    ..Default::default()
+                }),
             )
             .expect("read request must build");
         assert!(
@@ -1220,7 +1237,10 @@ mod tests {
             .gcs_get_object_request(
                 "object",
                 BytesRange::default(),
-                &OpRead::default().with_if_version_match("0"),
+                &read_args(options::ReadOptions {
+                    if_version_match: Some("0".to_owned()),
+                    ..Default::default()
+                }),
             )
             .expect("generation zero must be forwarded");
         assert!(
@@ -1234,7 +1254,11 @@ mod tests {
         let stat = core
             .gcs_head_object_request(
                 "object",
-                &OpStat::default().with_if_version_not_match("456"),
+                &options::StatOptions {
+                    if_version_not_match: Some("456".to_owned()),
+                    ..Default::default()
+                }
+                .into(),
             )
             .expect("stat request must build");
         assert!(
@@ -1248,9 +1272,11 @@ mod tests {
             .gcs_insert_object_request(
                 "object",
                 Some(0),
-                &OpWrite::default()
-                    .with_if_not_exists(true)
-                    .with_if_version_match("123"),
+                &write_args(options::WriteOptions {
+                    if_not_exists: true,
+                    if_version_match: Some("123".to_owned()),
+                    ..Default::default()
+                }),
                 Buffer::new(),
             )
             .expect("write request must build");
@@ -1261,7 +1287,11 @@ mod tests {
         let delete = core
             .gcs_delete_object_request(
                 "object",
-                &OpDelete::default().with_if_version_not_match("456"),
+                &options::DeleteOptions {
+                    if_version_not_match: Some("456".to_owned()),
+                    ..Default::default()
+                }
+                .into(),
             )
             .expect("delete request must build");
         assert!(
@@ -1275,9 +1305,11 @@ mod tests {
         let resumable = core
             .gcs_initiate_resumable_upload_request(
                 "object",
-                &OpWrite::default()
-                    .with_if_not_exists(true)
-                    .with_if_version_match("123"),
+                &write_args(options::WriteOptions {
+                    if_not_exists: true,
+                    if_version_match: Some("123".to_owned()),
+                    ..Default::default()
+                }),
             )
             .expect("resumable request must build");
         let query = resumable.uri().query().unwrap();
@@ -1288,7 +1320,10 @@ mod tests {
             .gcs_rewrite_object_request(
                 "source",
                 "target",
-                &OpCopy::default().with_if_version_not_match("456"),
+                &copy_args(options::CopyOptions {
+                    if_version_not_match: Some("456".to_owned()),
+                    ..Default::default()
+                }),
                 Some(GCS_REWRITE_MIN_CHUNK_SIZE),
                 Some("token"),
             )
@@ -1301,9 +1336,11 @@ mod tests {
             .gcs_rewrite_object_request(
                 "source",
                 "target",
-                &OpCopy::default()
-                    .with_if_not_exists(true)
-                    .with_if_version_match("123"),
+                &copy_args(options::CopyOptions {
+                    if_not_exists: true,
+                    if_version_match: Some("123".to_owned()),
+                    ..Default::default()
+                }),
                 None,
                 None,
             )
@@ -1321,22 +1358,34 @@ mod tests {
             .gcs_get_object_xml_request(
                 "object",
                 BytesRange::default(),
-                &OpRead::default().with_if_version_match("123"),
+                &read_args(options::ReadOptions {
+                    if_version_match: Some("123".to_owned()),
+                    ..Default::default()
+                }),
             )
             .expect("read request must build");
         assert_eq!(read.headers()["x-goog-if-generation-match"], "123");
 
         let stat = core
-            .gcs_head_object_xml_request("object", &OpStat::default().with_if_version_match("123"))
+            .gcs_head_object_xml_request(
+                "object",
+                &options::StatOptions {
+                    if_version_match: Some("123".to_owned()),
+                    ..Default::default()
+                }
+                .into(),
+            )
             .expect("stat request must build");
         assert_eq!(stat.headers()["x-goog-if-generation-match"], "123");
 
         let write = core
             .gcs_insert_object_xml_request(
                 "object",
-                &OpWrite::default()
-                    .with_if_not_exists(true)
-                    .with_if_version_match("123"),
+                &write_args(options::WriteOptions {
+                    if_not_exists: true,
+                    if_version_match: Some("123".to_owned()),
+                    ..Default::default()
+                }),
                 Buffer::new(),
             )
             .expect("write request must build");
@@ -1353,7 +1402,10 @@ mod tests {
         let create = core
             .gcs_insert_object_xml_request(
                 "object",
-                &OpWrite::default().with_if_not_exists(true),
+                &write_args(options::WriteOptions {
+                    if_not_exists: true,
+                    ..Default::default()
+                }),
                 Buffer::new(),
             )
             .expect("create request must build");
@@ -1432,7 +1484,14 @@ mod tests {
         assert_eq!(meta.version(), Some("1660563214863653"));
 
         let metadata = HashMap::from_iter([("location".to_string(), "everywhere".to_string())]);
-        assert_eq!(meta.user_metadata(), Some(&metadata));
+        assert_eq!(
+            meta.user_metadata()
+                .expect("user metadata must be present")
+                .into_iter()
+                .map(|(key, value)| (key.to_owned(), value.to_owned()))
+                .collect::<HashMap<_, _>>(),
+            metadata
+        );
     }
 
     #[test]
diff --git a/core/services/gcs/src/lister.rs b/core/services/gcs/src/lister.rs
index edec6a502a..3a1f6a4248 100644
--- a/core/services/gcs/src/lister.rs
+++ b/core/services/gcs/src/lister.rs
@@ -100,7 +100,7 @@ impl oio::PageList for GcsLister {
         for prefix in output.prefixes {
             let de = oio::Entry::new(
                 &build_rel_path(&self.core.root, &prefix),
-                Metadata::new(EntryMode::DIR),
+                Metadata::builder(EntryMode::DIR).build(),
             );
 
             ctx.entries.push_back(de);
@@ -116,26 +116,26 @@ impl oio::PageList for GcsLister {
                 continue;
             }
 
-            let mut meta = Metadata::new(EntryMode::from_path(&path));
+            let mut meta = Metadata::builder(EntryMode::from_path(&path));
 
             // set metadata fields
-            meta.set_content_md5(object.md5_hash.as_str());
-            meta.set_etag(object.etag.as_str());
+            meta.content_md5(object.md5_hash.as_str());
+            meta.etag(object.etag.as_str());
             if !object.generation.is_empty() {
-                meta.set_version(&object.generation);
+                meta.version(&object.generation);
             }
 
             let size = object.size.parse().map_err(|e| {
                 Error::new(ErrorKind::Unexpected, "parse u64 from list response").set_source(e)
             })?;
-            meta.set_content_length(size);
+            meta.content_length(size);
             if !object.content_type.is_empty() {
-                meta.set_content_type(&object.content_type);
+                meta.content_type(&object.content_type);
             }
 
-            meta.set_last_modified(object.updated.parse::<Timestamp>()?);
+            meta.last_modified(object.updated.parse::<Timestamp>()?);
 
-            let de = oio::Entry::with(path, meta);
+            let de = oio::Entry::with(path, meta.build());
 
             ctx.entries.push_back(de);
         }
diff --git a/core/services/gcs/src/reader.rs b/core/services/gcs/src/reader.rs
index f57089d945..e2c71a6096 100644
--- a/core/services/gcs/src/reader.rs
+++ b/core/services/gcs/src/reader.rs
@@ -69,11 +69,11 @@ impl oio::StreamRead for GcsReader {
 
         let (rp, stream) = match status {
             StatusCode::OK | StatusCode::PARTIAL_CONTENT => {
-                let mut metadata = parse_into_metadata(path, resp.headers())?;
+                let mut metadata = parse_into_metadata(path, resp.headers())?.into_builder();
                 if let Some(generation) = parse_header_to_str(resp.headers(), X_GOOG_GENERATION)? {
-                    metadata.set_version(generation);
+                    metadata.version(generation);
                 }
-                (RpRead::new(metadata), resp.into_body())
+                (RpRead::new(metadata.build()), resp.into_body())
             }
             _ => {
                 let (part, mut body) = resp.into_parts();
diff --git a/core/services/gcs/src/writer.rs b/core/services/gcs/src/writer.rs
index 5f3a150525..d5e6ae6a34 100644
--- a/core/services/gcs/src/writer.rs
+++ b/core/services/gcs/src/writer.rs
@@ -163,14 +163,14 @@ impl oio::MultipartWrite for GcsWriter {
                 resp,
             ));
         }
-        let mut metadata = Metadata::new(EntryMode::from_path(&self.path));
+        let mut metadata = Metadata::builder(EntryMode::from_path(&self.path));
         if let Some(etag) = parse_etag(resp.headers())? {
-            metadata.set_etag(etag);
+            metadata.etag(etag);
         }
         if let Some(generation) = parse_header_to_str(resp.headers(), X_GOOG_GENERATION)? {
-            metadata.set_version(generation);
+            metadata.version(generation);
         }
-        Ok(metadata)
+        Ok(metadata.build())
     }
 
     async fn abort_part(&self, upload_id: &str) -> Result<()> {
diff --git a/core/services/gdrive/src/backend.rs b/core/services/gdrive/src/backend.rs
index 7248bf525c..d608626916 100644
--- a/core/services/gdrive/src/backend.rs
+++ b/core/services/gdrive/src/backend.rs
@@ -232,7 +232,7 @@ impl Service for GdriveBackend {
     ) -> Result<RpCreateDir> {
         let path = build_abs_path(&self.core.root, path);
         let dir_id = self.core.ensure_dir(ctx, &path).await?;
-        let metadata = Metadata::new(EntryMode::DIR);
+        let metadata = Metadata::builder(EntryMode::DIR).build();
 
         self.core.cache_dir_id(&path, &dir_id).await;
         self.core.record_recent_upsert(&path, metadata).await;
@@ -300,18 +300,19 @@ impl Service for GdriveBackend {
         } else {
             EntryMode::FILE
         };
-        let mut meta = Metadata::new(file_type).with_content_type(gdrive_file.mime_type);
+        let mut meta = Metadata::builder(file_type);
+        meta.content_type(gdrive_file.mime_type);
         if let Some(v) = gdrive_file.size {
-            meta = meta.with_content_length(v.parse::<u64>().map_err(|e| {
+            meta.content_length(v.parse::<u64>().map_err(|e| {
                 Error::new(ErrorKind::Unexpected, "parse content length").set_source(e)
             })?);
         }
         if let Some(v) = gdrive_file.modified_time {
-            meta = meta.with_last_modified(v.parse::<Timestamp>().map_err(|e| {
+            meta.last_modified(v.parse::<Timestamp>().map_err(|e| {
                 Error::new(ErrorKind::Unexpected, "parse last modified time").set_source(e)
             })?);
         }
-        Ok(RpStat::new(meta))
+        Ok(RpStat::new(meta.build()))
     }
     fn read(&self, ctx: &OperationContext, path: &str, args: OpRead) -> Result<Self::Reader> {
         let output: oio::StreamReader<GdriveReader> = {
@@ -394,27 +395,26 @@ impl Service for GdriveBackend {
                         .map_err(new_json_deserialize_error)?;
 
                     let to_path = build_abs_path(&core.root, &to);
-                    let mut metadata = if meta.mime_type == "application/vnd.google-apps.folder" {
-                        Metadata::new(EntryMode::DIR)
+                    let is_dir = meta.mime_type == "application/vnd.google-apps.folder";
+                    let mut metadata = if is_dir {
+                        Metadata::builder(EntryMode::DIR)
                     } else {
-                        Metadata::new(EntryMode::FILE)
+                        Metadata::builder(EntryMode::FILE)
                     };
                     if let Some(size) = meta.size {
-                        metadata =
-                            metadata.with_content_length(size.parse::<u64>().map_err(|e| {
-                                Error::new(ErrorKind::Unexpected, "parse content length")
-                                    .set_source(e)
-                            })?);
+                        metadata.content_length(size.parse::<u64>().map_err(|e| {
+                            Error::new(ErrorKind::Unexpected, "parse content length").set_source(e)
+                        })?);
                     }
 
-                    if metadata.mode().is_dir() {
+                    if is_dir {
                         core.cache_dir_id(&to_path, &meta.id).await;
                     } else {
                         core.cache_file_id(&to_path, &meta.id).await;
                     }
-                    core.record_recent_upsert(&to_path, metadata).await;
+                    core.record_recent_upsert(&to_path, metadata.build()).await;
 
-                    Ok(Metadata::default())
+                    Ok(Metadata::builder(EntryMode::Unknown).build())
                 }
                 StatusCode::NOT_FOUND => {
                     core.refresh_path(&source).await;
@@ -427,29 +427,27 @@ impl Service for GdriveBackend {
                                 .map_err(new_json_deserialize_error)?;
 
                             let to_path = build_abs_path(&core.root, &to);
-                            let mut metadata =
-                                if meta.mime_type == "application/vnd.google-apps.folder" {
-                                    Metadata::new(EntryMode::DIR)
-                                } else {
-                                    Metadata::new(EntryMode::FILE)
-                                };
+                            let is_dir = meta.mime_type == "application/vnd.google-apps.folder";
+                            let mut metadata = if is_dir {
+                                Metadata::builder(EntryMode::DIR)
+                            } else {
+                                Metadata::builder(EntryMode::FILE)
+                            };
                             if let Some(size) = meta.size {
-                                metadata = metadata.with_content_length(
-                                    size.parse::<u64>().map_err(|e| {
-                                        Error::new(ErrorKind::Unexpected, "parse content length")
-                                            .set_source(e)
-                                    })?,
-                                );
+                                metadata.content_length(size.parse::<u64>().map_err(|e| {
+                                    Error::new(ErrorKind::Unexpected, "parse content length")
+                                        .set_source(e)
+                                })?);
                             }
 
-                            if metadata.mode().is_dir() {
+                            if is_dir {
                                 core.cache_dir_id(&to_path, &meta.id).await;
                             } else {
                                 core.cache_file_id(&to_path, &meta.id).await;
                             }
-                            core.record_recent_upsert(&to_path, metadata).await;
+                            core.record_recent_upsert(&to_path, metadata.build()).await;
 
-                            Ok(Metadata::default())
+                            Ok(Metadata::builder(EntryMode::Unknown).build())
                         }
                         _ => Err(parse_error(
                             ErrorContext::new(ServiceOperation("CopyFile")),
@@ -501,18 +499,19 @@ impl Service for GdriveBackend {
                 } else {
                     build_abs_path(&self.core.root, to)
                 };
-                let mut metadata = if meta.mime_type == "application/vnd.google-apps.folder" {
-                    Metadata::new(EntryMode::DIR)
+                let is_dir = meta.mime_type == "application/vnd.google-apps.folder";
+                let mut metadata = if is_dir {
+                    Metadata::builder(EntryMode::DIR)
                 } else {
-                    Metadata::new(EntryMode::FILE)
+                    Metadata::builder(EntryMode::FILE)
                 };
                 if let Some(size) = meta.size {
-                    metadata = metadata.with_content_length(size.parse::<u64>().map_err(|e| {
+                    metadata.content_length(size.parse::<u64>().map_err(|e| {
                         Error::new(ErrorKind::Unexpected, "parse content length").set_source(e)
                     })?);
                 }
 
-                if metadata.mode().is_dir() {
+                if is_dir {
                     self.core.invalidate_dir_id(&source_path).await;
                     self.core.cache_dir_id(&target_path, &meta.id).await;
                 } else {
@@ -520,9 +519,18 @@ impl Service for GdriveBackend {
                     self.core.cache_file_id(&target_path, &meta.id).await;
                 }
                 self.core
-                    .record_recent_delete(&source_path, metadata.mode())
+                    .record_recent_delete(
+                        &source_path,
+                        if is_dir {
+                            EntryMode::DIR
+                        } else {
+                            EntryMode::FILE
+                        },
+                    )
+                    .await;
+                self.core
+                    .record_recent_upsert(&target_path, metadata.build())
                     .await;
-                self.core.record_recent_upsert(&target_path, metadata).await;
 
                 Ok(RpRename::default())
             }
@@ -556,18 +564,19 @@ impl Service for GdriveBackend {
                 } else {
                     build_abs_path(&self.core.root, to)
                 };
-                let mut metadata = if meta.mime_type == "application/vnd.google-apps.folder" {
-                    Metadata::new(EntryMode::DIR)
+                let is_dir = meta.mime_type == "application/vnd.google-apps.folder";
+                let mut metadata = if is_dir {
+                    Metadata::builder(EntryMode::DIR)
                 } else {
-                    Metadata::new(EntryMode::FILE)
+                    Metadata::builder(EntryMode::FILE)
                 };
                 if let Some(size) = meta.size {
-                    metadata = metadata.with_content_length(size.parse::<u64>().map_err(|e| {
+                    metadata.content_length(size.parse::<u64>().map_err(|e| {
                         Error::new(ErrorKind::Unexpected, "parse content length").set_source(e)
                     })?);
                 }
 
-                if metadata.mode().is_dir() {
+                if is_dir {
                     self.core.invalidate_dir_id(&source_path).await;
                     self.core.cache_dir_id(&target_path, &meta.id).await;
                 } else {
@@ -575,9 +584,18 @@ impl Service for GdriveBackend {
                     self.core.cache_file_id(&target_path, &meta.id).await;
                 }
                 self.core
-                    .record_recent_delete(&source_path, metadata.mode())
+                    .record_recent_delete(
+                        &source_path,
+                        if is_dir {
+                            EntryMode::DIR
+                        } else {
+                            EntryMode::FILE
+                        },
+                    )
+                    .await;
+                self.core
+                    .record_recent_upsert(&target_path, metadata.build())
                     .await;
-                self.core.record_recent_upsert(&target_path, metadata).await;
 
                 Ok(RpRename::default())
             }
diff --git a/core/services/gdrive/src/core.rs b/core/services/gdrive/src/core.rs
index d8b68ac7b1..57fa732696 100644
--- a/core/services/gdrive/src/core.rs
+++ b/core/services/gdrive/src/core.rs
@@ -649,7 +649,7 @@ fn revive_recent_parent_dirs(entries: &mut GdriveRecentState, path: &str, expire
                 &parent,
                 EntryMode::DIR,
                 GdriveRecentEntry {
-                    metadata: Some(Metadata::new(EntryMode::DIR)),
+                    metadata: Some(Metadata::builder(EntryMode::DIR).build()),
                     expires_at,
                 },
             );
@@ -954,15 +954,19 @@ mod tests {
     async fn test_recent_entries_for_direct_list() {
         let core = mock_gdrive_core();
 
+        core.record_recent_upsert("parent/file.txt", {
+            let mut metadata = Metadata::builder(EntryMode::FILE);
+            metadata.content_length(5);
+            metadata.build()
+        })
+        .await;
+        core.record_recent_upsert("parent/dir/", Metadata::builder(EntryMode::DIR).build())
+            .await;
         core.record_recent_upsert(
-            "parent/file.txt",
-            Metadata::new(EntryMode::FILE).with_content_length(5),
+            "parent/nested/file.txt",
+            Metadata::builder(EntryMode::FILE).build(),
         )
         .await;
-        core.record_recent_upsert("parent/dir/", Metadata::new(EntryMode::DIR))
-            .await;
-        core.record_recent_upsert("parent/nested/file.txt", Metadata::new(EntryMode::FILE))
-            .await;
         core.record_recent_delete("parent/deleted.txt", EntryMode::FILE)
             .await;
 
@@ -982,13 +986,19 @@ mod tests {
     async fn test_recent_entries_for_recursive_prefix_list() {
         let core = mock_gdrive_core();
 
-        core.record_recent_upsert("parent/file.txt", Metadata::new(EntryMode::FILE))
-            .await;
-        core.record_recent_upsert("parent/nested/file.txt", Metadata::new(EntryMode::FILE))
-            .await;
-        core.record_recent_upsert("prefix", Metadata::new(EntryMode::FILE))
+        core.record_recent_upsert(
+            "parent/file.txt",
+            Metadata::builder(EntryMode::FILE).build(),
+        )
+        .await;
+        core.record_recent_upsert(
+            "parent/nested/file.txt",
+            Metadata::builder(EntryMode::FILE).build(),
+        )
+        .await;
+        core.record_recent_upsert("prefix", Metadata::builder(EntryMode::FILE).build())
             .await;
-        core.record_recent_upsert("prefix-child", Metadata::new(EntryMode::FILE))
+        core.record_recent_upsert("prefix-child", Metadata::builder(EntryMode::FILE).build())
             .await;
 
         let parent_entries = core.recent_entries_for_list("parent/", true).await;
@@ -1019,7 +1029,7 @@ mod tests {
     async fn test_recent_entry_for_dir_alias() {
         let core = mock_gdrive_core();
 
-        core.record_recent_upsert("parent/dir/", Metadata::new(EntryMode::DIR))
+        core.record_recent_upsert("parent/dir/", Metadata::builder(EntryMode::DIR).build())
             .await;
 
         match core.recent_entry_for_path("parent/dir").await {
@@ -1032,10 +1042,11 @@ mod tests {
     async fn test_recent_tombstone_hides_descendants_until_recreated() {
         let core = mock_gdrive_core();
 
-        core.record_recent_upsert(
-            "parent/dir/stale.txt",
-            Metadata::new(EntryMode::FILE).with_content_length(1),
-        )
+        core.record_recent_upsert("parent/dir/stale.txt", {
+            let mut metadata = Metadata::builder(EntryMode::FILE);
+            metadata.content_length(1);
+            metadata.build()
+        })
         .await;
         core.record_recent_delete("parent/dir/", EntryMode::DIR)
             .await;
@@ -1055,10 +1066,11 @@ mod tests {
             other => panic!("unexpected state for stale child: {other:?}"),
         }
 
-        core.record_recent_upsert(
-            "parent/dir/file.txt",
-            Metadata::new(EntryMode::FILE).with_content_length(1),
-        )
+        core.record_recent_upsert("parent/dir/file.txt", {
+            let mut metadata = Metadata::builder(EntryMode::FILE);
+            metadata.content_length(1);
+            metadata.build()
+        })
         .await;
 
         match core.recent_entry_for_path("parent/dir").await {
diff --git a/core/services/gdrive/src/lister.rs b/core/services/gdrive/src/lister.rs
index a2a7473046..c81b9cb7bd 100644
--- a/core/services/gdrive/src/lister.rs
+++ b/core/services/gdrive/src/lister.rs
@@ -99,28 +99,27 @@ impl GdriveLister {
 }
 
 fn metadata_from_gdrive_file(file: &GdriveFile) -> Result<Metadata> {
-    let mut metadata = Metadata::new(
+    let mut metadata = Metadata::builder(
         if file.mime_type.as_str() == "application/vnd.google-apps.folder" {
             EntryMode::DIR
         } else {
             EntryMode::FILE
         },
-    )
-    .with_content_type(file.mime_type.clone());
+    );
+    metadata.content_type(file.mime_type.clone());
 
     if let Some(size) = &file.size {
-        metadata = metadata.with_content_length(size.parse::<u64>().map_err(|e| {
+        metadata.content_length(size.parse::<u64>().map_err(|e| {
             Error::new(ErrorKind::Unexpected, "parse content length").set_source(e)
         })?);
     }
     if let Some(modified_time) = &file.modified_time {
-        metadata =
-            metadata.with_last_modified(modified_time.parse::<Timestamp>().map_err(|e| {
-                Error::new(ErrorKind::Unexpected, "parse last modified time").set_source(e)
-            })?);
+        metadata.last_modified(modified_time.parse::<Timestamp>().map_err(|e| {
+            Error::new(ErrorKind::Unexpected, "parse last modified time").set_source(e)
+        })?);
     }
 
-    Ok(metadata)
+    Ok(metadata.build())
 }
 
 impl oio::PageList for GdriveLister {
@@ -235,7 +234,7 @@ impl oio::PageList for GdriveLister {
         // Include the current directory itself when handling the first page of the listing.
         if ctx.token.is_empty() && !ctx.done {
             let path = build_rel_path(&self.core.root, &self.path);
-            self.push_entry(ctx, path, Metadata::new(EntryMode::DIR))
+            self.push_entry(ctx, path, Metadata::builder(EntryMode::DIR).build())
                 .await?;
             self.inject_recent_entries(ctx).await?;
         }
@@ -555,7 +554,7 @@ impl GdriveFlatLister {
             if !rel_path.is_empty() && !rel_path.ends_with('/') {
                 rel_path.push('/');
             }
-            self.push_entry(rel_path, Metadata::new(EntryMode::DIR));
+            self.push_entry(rel_path, Metadata::builder(EntryMode::DIR).build());
 
             // Queue the root directory for listing.
             self.pending_dirs.push_back(PendingDir {
diff --git a/core/services/gdrive/src/writer.rs b/core/services/gdrive/src/writer.rs
index ce18d1e385..6c6fee64d6 100644
--- a/core/services/gdrive/src/writer.rs
+++ b/core/services/gdrive/src/writer.rs
@@ -87,18 +87,20 @@ impl oio::OneShotWrite for GdriveWriter {
 
             match resp.status() {
                 StatusCode::OK | StatusCode::CREATED => {
-                    let mut metadata =
-                        Metadata::new(EntryMode::FILE).with_content_length(size as u64);
+                    let mut metadata = Metadata::builder(EntryMode::FILE);
+                    metadata.content_length(size as u64);
 
                     if current_file_id.is_none() {
                         let bs = resp.into_body();
                         let file: GdriveFile = serde_json::from_reader(bs.reader())
                             .map_err(new_json_deserialize_error)?;
-                        metadata = metadata.with_content_type(file.mime_type);
+                        metadata.content_type(file.mime_type);
                         self.core.cache_file_id(&self.path, &file.id).await;
                     }
-                    self.core.record_recent_upsert(&self.path, metadata).await;
-                    return Ok(Metadata::default());
+                    self.core
+                        .record_recent_upsert(&self.path, metadata.build())
+                        .await;
+                    return Ok(Metadata::builder(EntryMode::Unknown).build());
                 }
                 StatusCode::NOT_FOUND if !retried && current_file_id.is_some() => {
                     retried = true;
diff --git a/core/services/ghac/src/writer.rs b/core/services/ghac/src/writer.rs
index ce6aa12a8c..7518904bd6 100644
--- a/core/services/ghac/src/writer.rs
+++ b/core/services/ghac/src/writer.rs
@@ -248,7 +248,11 @@ impl oio::Write for GhacWriterV1 {
         self.core
             .ghac_finalize_upload(&self.ctx, &self.path, &self.url, self.size)
             .await?;
-        Ok(Metadata::default().with_content_length(self.size))
+        Ok({
+            let mut metadata = Metadata::builder(EntryMode::Unknown);
+            metadata.content_length(self.size);
+            metadata.build()
+        })
     }
 }
 
@@ -276,7 +280,11 @@ impl oio::Write for GhacWriterV2 {
         self.core
             .ghac_finalize_upload(&self.ctx, &self.path, &self.url, self.size)
             .await?;
-        Ok(Metadata::default().with_content_length(self.size))
+        Ok({
+            let mut metadata = Metadata::builder(EntryMode::Unknown);
+            metadata.content_length(self.size);
+            metadata.build()
+        })
     }
 
     async fn abort(&mut self) -> Result<()> {
diff --git a/core/services/github/src/backend.rs b/core/services/github/src/backend.rs
index 290569b14c..94147e31ec 100644
--- a/core/services/github/src/backend.rs
+++ b/core/services/github/src/backend.rs
@@ -206,11 +206,13 @@ impl Service for GithubBackend {
                     serde_json::from_reader(body.reader()).map_err(new_json_deserialize_error)?;
 
                 let m = if resp.type_field == "dir" {
-                    Metadata::new(EntryMode::DIR)
+                    Metadata::builder(EntryMode::DIR).build()
                 } else {
-                    Metadata::new(EntryMode::FILE)
-                        .with_content_length(resp.size)
-                        .with_etag(resp.sha)
+                    {
+                        let mut metadata = Metadata::builder(EntryMode::FILE);
+                        metadata.content_length(resp.size).etag(resp.sha);
+                        metadata.build()
+                    }
                 };
 
                 Ok(RpStat::new(m))
diff --git a/core/services/github/src/lister.rs b/core/services/github/src/lister.rs
index 75d3532530..390d59e946 100644
--- a/core/services/github/src/lister.rs
+++ b/core/services/github/src/lister.rs
@@ -56,22 +56,21 @@ impl oio::PageList for GithubLister {
                 let path = build_rel_path(&self.core.root, &entry.path);
                 let entry = if entry.type_field == "dir" {
                     let path = format!("{path}/");
-                    Entry::new(&path, Metadata::new(EntryMode::DIR))
+                    Entry::new(&path, Metadata::builder(EntryMode::DIR).build())
                 } else {
                     if path.ends_with(".gitkeep") {
                         continue;
                     }
-                    let m = Metadata::new(EntryMode::FILE)
-                        .with_content_length(entry.size)
-                        .with_etag(entry.sha);
-                    Entry::new(&path, m)
+                    let mut m = Metadata::builder(EntryMode::FILE);
+                    m.content_length(entry.size).etag(entry.sha);
+                    Entry::new(&path, m.build())
                 };
                 ctx.entries.push_back(entry);
             }
             if !self.path.ends_with('/') {
                 ctx.entries.push_back(Entry::new(
                     &format!("{}/", self.path),
-                    Metadata::new(EntryMode::DIR),
+                    Metadata::builder(EntryMode::DIR).build(),
                 ));
             }
             return Ok(());
@@ -91,24 +90,25 @@ impl oio::PageList for GithubLister {
             };
             let entry = if t.type_field == "tree" {
                 let path = format!("{path}/");
-                Entry::new(&path, Metadata::new(EntryMode::DIR))
+                Entry::new(&path, Metadata::builder(EntryMode::DIR).build())
             } else {
                 if path.ends_with(".gitkeep") {
                     continue;
                 }
-                let mut m = Metadata::new(EntryMode::FILE).with_etag(t.sha);
+                let mut m = Metadata::builder(EntryMode::FILE);
+                m.etag(t.sha);
 
                 if let Some(size) = t.size {
-                    m = m.with_content_length(size);
+                    m.content_length(size);
                 }
-                Entry::new(&path, m)
+                Entry::new(&path, m.build())
             };
             ctx.entries.push_back(entry);
         }
         if !self.path.ends_with('/') {
             ctx.entries.push_back(Entry::new(
                 &format!("{}/", self.path),
-                Metadata::new(EntryMode::DIR),
+                Metadata::builder(EntryMode::DIR).build(),
             ));
         }
 
diff --git a/core/services/github/src/writer.rs b/core/services/github/src/writer.rs
index c925b86c76..581580fbd8 100644
--- a/core/services/github/src/writer.rs
+++ b/core/services/github/src/writer.rs
@@ -45,13 +45,13 @@ impl GithubWriter {
             EntryMode::FILE
         };
 
-        let mut meta = Metadata::new(mode);
+        let mut meta = Metadata::builder(mode);
         if mode == EntryMode::FILE {
-            meta.set_content_length(content.size);
-            meta.set_etag(&content.sha);
+            meta.content_length(content.size);
+            meta.etag(&content.sha);
         }
 
-        Ok(meta)
+        Ok(meta.build())
     }
 }
 
diff --git a/core/services/goosefs/src/core.rs b/core/services/goosefs/src/core.rs
index 0259bba36b..6d8b2921c9 100644
--- a/core/services/goosefs/src/core.rs
+++ b/core/services/goosefs/src/core.rs
@@ -548,25 +548,25 @@ impl GoosefsCore {
     /// Convert goosefs FileInfo to OpenDAL Metadata.
     pub fn file_info_to_metadata(&self, info: &FileInfo) -> Metadata {
         let mut metadata = if info.folder.unwrap_or(false) {
-            Metadata::new(EntryMode::DIR)
+            Metadata::builder(EntryMode::DIR)
         } else {
-            Metadata::new(EntryMode::FILE)
+            Metadata::builder(EntryMode::FILE)
         };
 
         if let Some(length) = info.length {
-            metadata.set_content_length(length as u64);
+            metadata.content_length(length as u64);
         }
         if let Some(mtime) = info.last_modification_time_ms
             && let Ok(ts) = Timestamp::from_millisecond(mtime)
         {
-            metadata.set_last_modified(ts);
+            metadata.last_modified(ts);
         }
         // GooseFS Master rename preserves the same inode id; use it as etag
         // for cache keys / checkout short-circuit (not commit conflict detection).
         if let Some(fid) = info.file_id {
-            metadata.set_etag(&fid.to_string());
+            metadata.etag(fid.to_string());
         }
-        metadata
+        metadata.build()
     }
 
     /// Convert goosefs FileInfo to OpenDAL Metadata (for list results),
diff --git a/core/services/goosefs/src/lister.rs b/core/services/goosefs/src/lister.rs
index a5e2b3a6fb..15cb7b9598 100644
--- a/core/services/goosefs/src/lister.rs
+++ b/core/services/goosefs/src/lister.rs
@@ -64,8 +64,10 @@ impl oio::PageList for GoosefsLister {
                 // no "self" entry in OpenDAL semantics, so we skip the
                 // synthesis for it.
                 if !self.path.is_empty() && self.path.ends_with('/') {
-                    ctx.entries
-                        .push_back(Entry::new(&self.path, Metadata::new(EntryMode::DIR)));
+                    ctx.entries.push_back(Entry::new(
+                        &self.path,
+                        Metadata::builder(EntryMode::DIR).build(),
+                    ));
                 }
 
                 for file_info in file_infos {
diff --git a/core/services/goosefs/src/writer.rs b/core/services/goosefs/src/writer.rs
index 37b9ac45c4..511cc16f0d 100644
--- a/core/services/goosefs/src/writer.rs
+++ b/core/services/goosefs/src/writer.rs
@@ -251,12 +251,12 @@ impl oio::Write for GoosefsWriter {
                 return Err(e);
             }
             // Capture file_id before rename; Master rename keeps the same inode id.
-            let mut meta = Metadata::default();
+            let mut meta = Metadata::builder(EntryMode::Unknown);
             if let Some(fid) = writer.file_info().file_id {
-                meta.set_etag(&fid.to_string());
+                meta.etag(fid.to_string());
             }
             self.finalize_rename().await?;
-            return Ok(meta);
+            return Ok(meta.build());
         }
 
         // Zero-write path: the caller closed without ever calling
@@ -282,13 +282,13 @@ impl oio::Write for GoosefsWriter {
             let _ = self.core.delete(&tmp).await;
             return Err(e);
         }
-        let mut meta = Metadata::default();
+        let mut meta = Metadata::builder(EntryMode::Unknown);
         if let Some(fid) = w.file_info().file_id {
-            meta.set_etag(&fid.to_string());
+            meta.etag(fid.to_string());
         }
         self.tmp_path = Some(tmp);
         self.finalize_rename().await?;
-        Ok(meta)
+        Ok(meta.build())
     }
 
     async fn abort(&mut self) -> Result<()> {
diff --git a/core/services/gridfs/src/backend.rs b/core/services/gridfs/src/backend.rs
index a96990ad0c..db9fb901de 100644
--- a/core/services/gridfs/src/backend.rs
+++ b/core/services/gridfs/src/backend.rs
@@ -224,12 +224,14 @@ impl Service for GridfsBackend {
         let p = build_abs_path(&self.root, path);
 
         if p == build_abs_path(&self.root, "") {
-            Ok(RpStat::new(Metadata::new(EntryMode::DIR)))
+            Ok(RpStat::new(Metadata::builder(EntryMode::DIR).build()))
         } else {
             match self.core.get_length(&p).await? {
-                Some(len) => Ok(RpStat::new(
-                    Metadata::new(EntryMode::FILE).with_content_length(len as u64),
-                )),
+                Some(len) => Ok(RpStat::new({
+                    let mut metadata = Metadata::builder(EntryMode::FILE);
+                    metadata.content_length(len as u64);
+                    metadata.build()
+                })),
                 None => Err(Error::new(ErrorKind::NotFound, "kv not found in gridfs")),
             }
         }
diff --git a/core/services/gridfs/src/reader.rs b/core/services/gridfs/src/reader.rs
index 81eca60eb0..99467d4639 100644
--- a/core/services/gridfs/src/reader.rs
+++ b/core/services/gridfs/src/reader.rs
@@ -46,7 +46,11 @@ impl oio::StreamRead for GridfsReader {
             }
         };
         let content = bs.slice(range.to_content_range(bs.len())?);
-        let metadata = Metadata::new(EntryMode::FILE).with_content_length(bs.len() as u64);
+        let metadata = {
+            let mut metadata = Metadata::builder(EntryMode::FILE);
+            metadata.content_length(bs.len() as u64);
+            metadata.build()
+        };
         Ok((
             RpRead::new(metadata),
             Box::new(content) as Box<dyn oio::ReadStreamDyn>,
diff --git a/core/services/gridfs/src/writer.rs b/core/services/gridfs/src/writer.rs
index 6e19e74a12..94ff865d5b 100644
--- a/core/services/gridfs/src/writer.rs
+++ b/core/services/gridfs/src/writer.rs
@@ -49,7 +49,11 @@ impl oio::Write for GridfsWriter {
         let length = buf.len() as u64;
         self.core.set(&self.path, buf).await?;
 
-        let meta = Metadata::new(EntryMode::from_path(&self.path)).with_content_length(length);
+        let meta = {
+            let mut metadata = Metadata::builder(EntryMode::from_path(&self.path));
+            metadata.content_length(length);
+            metadata.build()
+        };
         Ok(meta)
     }
 
diff --git a/core/services/hdfs-native/src/core.rs b/core/services/hdfs-native/src/core.rs
index e944bdcd00..1d5e969fb4 100644
--- a/core/services/hdfs-native/src/core.rs
+++ b/core/services/hdfs-native/src/core.rs
@@ -68,14 +68,14 @@ impl HdfsNativeCore {
             EntryMode::FILE
         };
 
-        let mut metadata = Metadata::new(mode);
+        let mut metadata = Metadata::builder(mode);
         metadata
-            .set_last_modified(Timestamp::from_millisecond(
+            .last_modified(Timestamp::from_millisecond(
                 status.modification_time as i64,
             )?)
-            .set_content_length(status.length as u64);
+            .content_length(status.length as u64);
 
-        Ok(metadata)
+        Ok(metadata.build())
     }
 
     pub async fn hdfs_open(&self, path: &str) -> Result<hdfs_native::file::FileReader> {
diff --git a/core/services/hdfs-native/src/lister.rs b/core/services/hdfs-native/src/lister.rs
index ea9efa8ff9..284d817cd9 100644
--- a/core/services/hdfs-native/src/lister.rs
+++ b/core/services/hdfs-native/src/lister.rs
@@ -54,7 +54,10 @@ impl oio::List for HdfsNativeLister {
         }
 
         if let Some(path) = self.current_path.take() {
-            return Ok(Some(oio::Entry::new(&path, Metadata::new(EntryMode::DIR))));
+            return Ok(Some(oio::Entry::new(
+                &path,
+                Metadata::builder(EntryMode::DIR).build(),
+            )));
         }
 
         match self.iter.next().await {
@@ -62,14 +65,16 @@ impl oio::List for HdfsNativeLister {
                 let path = build_rel_path(&self.root, &status.path);
 
                 let entry = if status.isdir {
-                    oio::Entry::new(&format!("{path}/"), Metadata::new(EntryMode::DIR))
+                    oio::Entry::new(
+                        &format!("{path}/"),
+                        Metadata::builder(EntryMode::DIR).build(),
+                    )
                 } else {
-                    let meta = Metadata::new(EntryMode::FILE)
-                        .with_content_length(status.length as u64)
-                        .with_last_modified(Timestamp::from_millisecond(
-                            status.modification_time as i64,
-                        )?);
-                    oio::Entry::new(&path, meta)
+                    let mut meta = Metadata::builder(EntryMode::FILE);
+                    meta.content_length(status.length as u64).last_modified(
+                        Timestamp::from_millisecond(status.modification_time as i64)?,
+                    );
+                    oio::Entry::new(&path, meta.build())
                 };
 
                 Ok(Some(entry))
diff --git a/core/services/hdfs-native/src/writer.rs b/core/services/hdfs-native/src/writer.rs
index 7bf54e2edb..5345bc9510 100644
--- a/core/services/hdfs-native/src/writer.rs
+++ b/core/services/hdfs-native/src/writer.rs
@@ -49,7 +49,11 @@ impl oio::Write for HdfsNativeWriter {
     async fn close(&mut self) -> Result<Metadata> {
         self.f.close().await.map_err(parse_hdfs_error)?;
 
-        Ok(Metadata::default().with_content_length(self.size))
+        Ok({
+            let mut metadata = Metadata::builder(EntryMode::Unknown);
+            metadata.content_length(self.size);
+            metadata.build()
+        })
     }
 
     async fn abort(&mut self) -> Result<()> {
diff --git a/core/services/hdfs/src/core.rs b/core/services/hdfs/src/core.rs
index 23658458e7..82e7ee21b9 100644
--- a/core/services/hdfs/src/core.rs
+++ b/core/services/hdfs/src/core.rs
@@ -72,11 +72,11 @@ impl HdfsCore {
         } else {
             EntryMode::Unknown
         };
-        let mut m = Metadata::new(mode);
-        m.set_content_length(meta.len());
-        m.set_last_modified(Timestamp::try_from(meta.modified())?);
+        let mut m = Metadata::builder(mode);
+        m.content_length(meta.len());
+        m.last_modified(Timestamp::try_from(meta.modified())?);
 
-        Ok(m)
+        Ok(m.build())
     }
 
     pub async fn hdfs_open(&self, path: &str) -> Result<hdrs::File> {
diff --git a/core/services/hdfs/src/lister.rs b/core/services/hdfs/src/lister.rs
index e97dd0eae9..ab68122a9d 100644
--- a/core/services/hdfs/src/lister.rs
+++ b/core/services/hdfs/src/lister.rs
@@ -43,7 +43,10 @@ impl HdfsLister {
 impl oio::List for HdfsLister {
     async fn next(&mut self) -> Result<Option<oio::Entry>> {
         if let Some(path) = self.current_path.take() {
-            return Ok(Some(oio::Entry::new(&path, Metadata::new(EntryMode::DIR))));
+            return Ok(Some(oio::Entry::new(
+                &path,
+                Metadata::builder(EntryMode::DIR).build(),
+            )));
         }
 
         let de = match self.rd.next() {
@@ -54,15 +57,18 @@ impl oio::List for HdfsLister {
         let path = build_rel_path(&self.root, de.path());
 
         let entry = if de.is_file() {
-            let meta = Metadata::new(EntryMode::FILE)
-                .with_content_length(de.len())
-                .with_last_modified(Timestamp::try_from(de.modified())?);
-            oio::Entry::new(&path, meta)
+            let mut meta = Metadata::builder(EntryMode::FILE);
+            meta.content_length(de.len())
+                .last_modified(Timestamp::try_from(de.modified())?);
+            oio::Entry::new(&path, meta.build())
         } else if de.is_dir() {
             // Make sure we are returning the correct path.
-            oio::Entry::new(&format!("{path}/"), Metadata::new(EntryMode::DIR))
+            oio::Entry::new(
+                &format!("{path}/"),
+                Metadata::builder(EntryMode::DIR).build(),
+            )
         } else {
-            oio::Entry::new(&path, Metadata::new(EntryMode::Unknown))
+            oio::Entry::new(&path, Metadata::builder(EntryMode::Unknown).build())
         };
 
         Ok(Some(entry))
diff --git a/core/services/hdfs/src/writer.rs b/core/services/hdfs/src/writer.rs
index 0c5aec3b2d..e3c9d8d713 100644
--- a/core/services/hdfs/src/writer.rs
+++ b/core/services/hdfs/src/writer.rs
@@ -92,7 +92,11 @@ impl oio::Write for HdfsWriter<hdrs::AsyncFile> {
                 .map_err(new_std_io_error)?
         }
 
-        Ok(Metadata::default().with_content_length(self.size))
+        Ok({
+            let mut metadata = Metadata::builder(EntryMode::Unknown);
+            metadata.content_length(self.size);
+            metadata.build()
+        })
     }
 
     async fn abort(&mut self) -> Result<()> {
diff --git a/core/services/hf/src/backend.rs b/core/services/hf/src/backend.rs
index ad26953b19..e54848aa33 100644
--- a/core/services/hf/src/backend.rs
+++ b/core/services/hf/src/backend.rs
@@ -310,12 +310,12 @@ impl Service for HfBackend {
     async fn stat(&self, ctx: &OperationContext, path: &str, _: OpStat) -> Result<RpStat> {
         // Stat root always returns a DIR.
         if path == "/" {
-            return Ok(RpStat::new(Metadata::new(EntryMode::DIR)));
+            return Ok(RpStat::new(Metadata::builder(EntryMode::DIR).build()));
         }
 
         // Buckets have no git directory entries; treat any trailing-slash path as a virtual dir.
         if self.core.repo.is_bucket() && path.ends_with('/') {
-            return Ok(RpStat::new(Metadata::new(EntryMode::DIR)));
+            return Ok(RpStat::new(Metadata::builder(EntryMode::DIR).build()));
         }
 
         let info = self.core.path_info(ctx, path).await?;
diff --git a/core/services/hf/src/core.rs b/core/services/hf/src/core.rs
index 575856ae66..48efe5692b 100644
--- a/core/services/hf/src/core.rs
+++ b/core/services/hf/src/core.rs
@@ -267,23 +267,23 @@ impl PathInfo {
 
     pub fn metadata(&self) -> Result<Metadata> {
         let mode = self.entry_mode();
-        let mut meta = Metadata::new(mode);
+        let mut meta = Metadata::builder(mode);
 
         if let Some(commit_info) = self.last_commit.as_ref() {
-            meta.set_last_modified(commit_info.date.parse::<Timestamp>()?);
+            meta.last_modified(commit_info.date.parse::<Timestamp>()?);
         }
 
         if mode == EntryMode::FILE {
-            meta.set_content_length(self.size);
+            meta.content_length(self.size);
             // For buckets, oid may be None; for regular repos, prefer lfs.oid then oid
             if let Some(lfs) = &self.lfs {
-                meta.set_etag(&lfs.oid);
+                meta.etag(&lfs.oid);
             } else if let Some(oid) = &self.oid {
-                meta.set_etag(oid);
+                meta.etag(oid);
             }
         }
 
-        Ok(meta)
+        Ok(meta.build())
     }
 }
 
diff --git a/core/services/hf/src/reader.rs b/core/services/hf/src/reader.rs
index 8375acad63..f8f2f8fc07 100644
--- a/core/services/hf/src/reader.rs
+++ b/core/services/hf/src/reader.rs
@@ -53,7 +53,11 @@ impl HfReadStream {
         size: u64,
         range: BytesRange,
     ) -> Result<(RpRead, Self)> {
-        let metadata = Metadata::new(EntryMode::FILE).with_content_length(size);
+        let metadata = {
+            let mut metadata = Metadata::builder(EntryMode::FILE);
+            metadata.content_length(size);
+            metadata.build()
+        };
         let xet_range = xet_range(range);
 
         let mut stream = group
diff --git a/core/services/hf/src/writer.rs b/core/services/hf/src/writer.rs
index 70d9aa4e19..a0444d062b 100644
--- a/core/services/hf/src/writer.rs
+++ b/core/services/hf/src/writer.rs
@@ -128,7 +128,11 @@ impl HfWriter {
         let content_length = file_info
             .file_size()
             .expect("file_size must be set after finish()");
-        let meta = Metadata::default().with_content_length(content_length);
+        let meta = {
+            let mut metadata = Metadata::builder(EntryMode::Unknown);
+            metadata.content_length(content_length);
+            metadata.build()
+        };
 
         let repo_path = self.core.repo_path(&self.path);
         if self.core.repo.is_bucket() {
diff --git a/core/services/http/src/backend.rs b/core/services/http/src/backend.rs
index 3327946f6a..7679333c05 100644
--- a/core/services/http/src/backend.rs
+++ b/core/services/http/src/backend.rs
@@ -202,7 +202,7 @@ impl Service for HttpBackend {
     async fn stat(&self, ctx: &OperationContext, path: &str, args: OpStat) -> Result<RpStat> {
         // Stat root always returns a DIR.
         if path == "/" {
-            return Ok(RpStat::new(Metadata::new(EntryMode::DIR)));
+            return Ok(RpStat::new(Metadata::builder(EntryMode::DIR).build()));
         }
 
         let resp = self.core.http_head(ctx, path, &args).await?;
@@ -214,7 +214,7 @@ impl Service for HttpBackend {
             // HTTP Server like nginx could return FORBIDDEN if auto-index
             // is not enabled, we should ignore them.
             StatusCode::NOT_FOUND | StatusCode::FORBIDDEN if path.ends_with('/') => {
-                Ok(RpStat::new(Metadata::new(EntryMode::DIR)))
+                Ok(RpStat::new(Metadata::builder(EntryMode::DIR).build()))
             }
             _ => Err(parse_error(
                 ErrorContext::new(ServiceOperation("Head")),
diff --git a/core/services/ipfs/src/core.rs b/core/services/ipfs/src/core.rs
index 24f1f29cd0..9fec6f6cb1 100644
--- a/core/services/ipfs/src/core.rs
+++ b/core/services/ipfs/src/core.rs
@@ -207,7 +207,7 @@ impl IpfsCore {
     pub async fn ipfs_stat(&self, ctx: &OperationContext, path: &str) -> Result<Metadata> {
         // Stat root always returns a DIR.
         if path == "/" {
-            return Ok(Metadata::new(EntryMode::DIR));
+            return Ok(Metadata::builder(EntryMode::DIR).build());
         }
 
         let resp = self.ipfs_head(ctx, path).await?;
@@ -215,37 +215,39 @@ impl IpfsCore {
 
         match status {
             StatusCode::OK => {
-                let mut m = Metadata::new(EntryMode::Unknown);
+                let mut m = Metadata::builder(EntryMode::Unknown);
 
                 if let Some(v) = parse_content_length(resp.headers())? {
-                    m.set_content_length(v);
+                    m.content_length(v);
                 }
 
                 if let Some(v) = parse_content_type(resp.headers())? {
-                    m.set_content_type(v);
+                    m.content_type(v);
                 }
 
                 if let Some(v) = parse_etag(resp.headers())? {
-                    m.set_etag(v);
+                    m.etag(v);
 
                     if v.starts_with("\"DirIndex") {
-                        m.set_mode(EntryMode::DIR);
+                        m.mode(EntryMode::DIR);
                     } else {
-                        m.set_mode(EntryMode::FILE);
+                        m.mode(EntryMode::FILE);
                     }
                 } else {
                     // Some service will stream the output of DirIndex.
                     // If we don't have an etag, it's highly to be a dir.
-                    m.set_mode(EntryMode::DIR);
+                    m.mode(EntryMode::DIR);
                 }
 
                 if let Some(v) = parse_content_disposition(resp.headers())? {
-                    m.set_content_disposition(v);
+                    m.content_disposition(v);
                 }
 
-                Ok(m)
+                Ok(m.build())
+            }
+            StatusCode::FOUND | StatusCode::MOVED_PERMANENTLY => {
+                Ok(Metadata::builder(EntryMode::DIR).build())
             }
-            StatusCode::FOUND | StatusCode::MOVED_PERMANENTLY => Ok(Metadata::new(EntryMode::DIR)),
             _ => Err(parse_error(
                 ErrorContext::new(ServiceOperation("Resolve")),
                 resp,
diff --git a/core/services/ipmfs/src/backend.rs b/core/services/ipmfs/src/backend.rs
index 01aece464b..7ad9f741f8 100644
--- a/core/services/ipmfs/src/backend.rs
+++ b/core/services/ipmfs/src/backend.rs
@@ -197,7 +197,7 @@ impl Service for IpmfsBackend {
     async fn stat(&self, ctx: &OperationContext, path: &str, _: OpStat) -> Result<RpStat> {
         // Stat root always returns a DIR.
         if path == "/" {
-            return Ok(RpStat::new(Metadata::new(EntryMode::DIR)));
+            return Ok(RpStat::new(Metadata::builder(EntryMode::DIR).build()));
         }
 
         let resp = self.core.ipmfs_stat(ctx, path).await?;
@@ -217,10 +217,10 @@ impl Service for IpmfsBackend {
                     _ => EntryMode::Unknown,
                 };
 
-                let mut meta = Metadata::new(mode);
-                meta.set_content_length(res.size);
+                let mut meta = Metadata::builder(mode);
+                meta.content_length(res.size);
 
-                Ok(RpStat::new(meta))
+                Ok(RpStat::new(meta.build()))
             }
             _ => Err(parse_error(
                 ErrorContext::new(ServiceOperation("FilesStat")),
diff --git a/core/services/ipmfs/src/lister.rs b/core/services/ipmfs/src/lister.rs
index d67decde52..99afe2f566 100644
--- a/core/services/ipmfs/src/lister.rs
+++ b/core/services/ipmfs/src/lister.rs
@@ -67,8 +67,10 @@ impl oio::PageList for IpmfsLister {
             let path = build_abs_path(&self.root, self.path.as_str());
             let path = build_rel_path(&self.root, &path);
 
-            ctx.entries
-                .push_back(oio::Entry::new(&path, Metadata::new(EntryMode::DIR)));
+            ctx.entries.push_back(oio::Entry::new(
+                &path,
+                Metadata::builder(EntryMode::DIR).build(),
+            ));
         }
 
         let bs = resp.into_body();
@@ -90,10 +92,11 @@ impl oio::PageList for IpmfsLister {
                 EntryMode::Unknown => unreachable!(),
             };
 
-            ctx.entries.push_back(oio::Entry::new(
-                &path,
-                Metadata::new(object.mode()).with_content_length(object.size),
-            ));
+            ctx.entries.push_back(oio::Entry::new(&path, {
+                let mut metadata = Metadata::builder(object.mode());
+                metadata.content_length(object.size);
+                metadata.build()
+            }));
         }
 
         Ok(())
diff --git a/core/services/ipmfs/src/writer.rs b/core/services/ipmfs/src/writer.rs
index da36e69598..35c84d3433 100644
--- a/core/services/ipmfs/src/writer.rs
+++ b/core/services/ipmfs/src/writer.rs
@@ -43,7 +43,9 @@ impl oio::OneShotWrite for IpmfsWriter {
         let status = resp.status();
 
         match status {
-            StatusCode::CREATED | StatusCode::OK => Ok(Metadata::default()),
+            StatusCode::CREATED | StatusCode::OK => {
+                Ok(Metadata::builder(EntryMode::Unknown).build())
+            }
             _ => Err(parse_error(
                 ErrorContext::new(ServiceOperation("Add")),
                 resp,
diff --git a/core/services/koofr/src/backend.rs b/core/services/koofr/src/backend.rs
index bae2f08c3c..f97dd35456 100644
--- a/core/services/koofr/src/backend.rs
+++ b/core/services/koofr/src/backend.rs
@@ -231,13 +231,13 @@ impl Service for KoofrBackend {
                     EntryMode::FILE
                 };
 
-                let mut md = Metadata::new(mode);
+                let mut md = Metadata::builder(mode);
 
-                md.set_content_length(file.size)
-                    .set_content_type(&file.content_type)
-                    .set_last_modified(Timestamp::from_millisecond(file.modified)?);
+                md.content_length(file.size)
+                    .content_type(&file.content_type)
+                    .last_modified(Timestamp::from_millisecond(file.modified)?);
 
-                Ok(RpStat::new(md))
+                Ok(RpStat::new(md.build()))
             }
             _ => Err(parse_error(
                 ErrorContext::new(ServiceOperation("FilesInfo")),
@@ -305,7 +305,7 @@ impl Service for KoofrBackend {
         Ok(oio::OneShotCopier::new(async move {
             core.ensure_dir_exists(&ctx, &to).await?;
             if from == to {
-                Ok(Metadata::default())
+                Ok(Metadata::builder(EntryMode::Unknown).build())
             } else {
                 let resp = core.remove(&ctx, &to).await?;
 
@@ -322,7 +322,7 @@ impl Service for KoofrBackend {
                     let status = resp.status();
 
                     match status {
-                        StatusCode::OK => Ok(Metadata::default()),
+                        StatusCode::OK => Ok(Metadata::builder(EntryMode::Unknown).build()),
                         _ => Err(parse_error(
                             ErrorContext::new(ServiceOperation("FilesCopy")),
                             resp,
diff --git a/core/services/koofr/src/lister.rs b/core/services/koofr/src/lister.rs
index ca0ef7c126..eacfde3030 100644
--- a/core/services/koofr/src/lister.rs
+++ b/core/services/koofr/src/lister.rs
@@ -75,13 +75,13 @@ impl oio::PageList for KoofrLister {
 
             let entry = if file.ty == "dir" {
                 let path = format!("{path}/");
-                Entry::new(&path, Metadata::new(EntryMode::DIR))
+                Entry::new(&path, Metadata::builder(EntryMode::DIR).build())
             } else {
-                let m = Metadata::new(EntryMode::FILE)
-                    .with_content_length(file.size)
-                    .with_content_type(file.content_type)
-                    .with_last_modified(Timestamp::from_millisecond(file.modified)?);
-                Entry::new(&path, m)
+                let mut m = Metadata::builder(EntryMode::FILE);
+                m.content_length(file.size)
+                    .content_type(file.content_type)
+                    .last_modified(Timestamp::from_millisecond(file.modified)?);
+                Entry::new(&path, m.build())
             };
 
             ctx.entries.push_back(entry);
diff --git a/core/services/koofr/src/writer.rs b/core/services/koofr/src/writer.rs
index e19a1d5587..6fbb6e07e8 100644
--- a/core/services/koofr/src/writer.rs
+++ b/core/services/koofr/src/writer.rs
@@ -46,12 +46,12 @@ impl KoofrWriter {
             EntryMode::FILE
         };
 
-        let mut meta = Metadata::new(mode);
-        meta.set_content_length(file.size);
-        meta.set_content_type(&file.content_type);
-        meta.set_last_modified(Timestamp::from_millisecond(file.modified)?);
+        let mut meta = Metadata::builder(mode);
+        meta.content_length(file.size);
+        meta.content_type(&file.content_type);
+        meta.last_modified(Timestamp::from_millisecond(file.modified)?);
 
-        Ok(meta)
+        Ok(meta.build())
     }
 }
 
diff --git a/core/services/lakefs/src/backend.rs b/core/services/lakefs/src/backend.rs
index 63cddba659..ad7fdc0f71 100644
--- a/core/services/lakefs/src/backend.rs
+++ b/core/services/lakefs/src/backend.rs
@@ -215,7 +215,7 @@ impl Service for LakefsBackend {
     async fn stat(&self, ctx: &OperationContext, path: &str, _: OpStat) -> Result<RpStat> {
         // Stat root always returns a DIR.
         if path == "/" {
-            return Ok(RpStat::new(Metadata::new(EntryMode::DIR)));
+            return Ok(RpStat::new(Metadata::builder(EntryMode::DIR).build()));
         }
 
         let resp = self.core.get_object_metadata(ctx, path).await?;
@@ -311,7 +311,7 @@ impl Service for LakefsBackend {
             let status = resp.status();
 
             match status {
-                StatusCode::CREATED => Ok(Metadata::default()),
+                StatusCode::CREATED => Ok(Metadata::builder(EntryMode::Unknown).build()),
                 _ => Err(parse_error(
                     ErrorContext::new(ServiceOperation("CopyObject")),
                     resp,
diff --git a/core/services/lakefs/src/core.rs b/core/services/lakefs/src/core.rs
index 92588bb597..9f7029cf42 100644
--- a/core/services/lakefs/src/core.rs
+++ b/core/services/lakefs/src/core.rs
@@ -271,29 +271,29 @@ impl LakefsCore {
             EntryMode::FILE
         };
 
-        let mut meta = Metadata::new(mode);
+        let mut meta = Metadata::builder(mode);
 
         // Set checksum as etag
         if !status.checksum.is_empty() {
-            meta.set_etag(&status.checksum);
+            meta.etag(&status.checksum);
         }
 
         // Set content length
         if let Some(size) = status.size_bytes {
-            meta.set_content_length(size);
+            meta.content_length(size);
         }
 
         // Set content type
         if let Some(ref content_type) = status.content_type {
-            meta.set_content_type(content_type);
+            meta.content_type(content_type);
         }
 
         // Set last modified time
         if let Ok(timestamp) = Timestamp::from_second(status.mtime) {
-            meta.set_last_modified(timestamp);
+            meta.last_modified(timestamp);
         }
 
-        meta
+        meta.build()
     }
 }
 
diff --git a/core/services/lakefs/src/lister.rs b/core/services/lakefs/src/lister.rs
index 382acbcf57..6d7e751e2c 100644
--- a/core/services/lakefs/src/lister.rs
+++ b/core/services/lakefs/src/lister.rs
@@ -96,16 +96,16 @@ impl oio::PageList for LakefsLister {
                 _ => EntryMode::Unknown,
             };
 
-            let mut meta = Metadata::new(entry_type);
+            let mut meta = Metadata::builder(entry_type);
 
             if status.mtime != 0 {
-                meta.set_last_modified(Timestamp::from_second(status.mtime).unwrap());
+                meta.last_modified(Timestamp::from_second(status.mtime).unwrap());
             }
 
             if entry_type == EntryMode::FILE
                 && let Some(size_bytes) = status.size_bytes
             {
-                meta.set_content_length(size_bytes);
+                meta.content_length(size_bytes);
             }
 
             let path = if entry_type == EntryMode::DIR {
@@ -116,7 +116,7 @@ impl oio::PageList for LakefsLister {
 
             ctx.entries.push_back(oio::Entry::new(
                 &build_rel_path(&self.core.root, &path),
-                meta,
+                meta.build(),
             ));
         }
 
diff --git a/core/services/memcached/src/backend.rs b/core/services/memcached/src/backend.rs
index ae00d0971e..91ef3725fc 100644
--- a/core/services/memcached/src/backend.rs
+++ b/core/services/memcached/src/backend.rs
@@ -267,13 +267,15 @@ impl Service for MemcachedBackend {
         let p = build_abs_path(&self.root, path);
 
         if p == build_abs_path(&self.root, "") {
-            Ok(RpStat::new(Metadata::new(EntryMode::DIR)))
+            Ok(RpStat::new(Metadata::builder(EntryMode::DIR).build()))
         } else {
             let bs = self.core.get(&p).await?;
             match bs {
-                Some(bs) => Ok(RpStat::new(
-                    Metadata::new(EntryMode::FILE).with_content_length(bs.len() as u64),
-                )),
+                Some(bs) => Ok(RpStat::new({
+                    let mut metadata = Metadata::builder(EntryMode::FILE);
+                    metadata.content_length(bs.len() as u64);
+                    metadata.build()
+                })),
                 None => Err(Error::new(ErrorKind::NotFound, "kv not found in memcached")),
             }
         }
diff --git a/core/services/memcached/src/reader.rs b/core/services/memcached/src/reader.rs
index 2d1764a19c..5c0f7972a3 100644
--- a/core/services/memcached/src/reader.rs
+++ b/core/services/memcached/src/reader.rs
@@ -44,7 +44,11 @@ impl oio::StreamRead for MemcachedReader {
             None => return Err(Error::new(ErrorKind::NotFound, "kv not found in memcached")),
         };
         let content = bs.slice(range.to_content_range(bs.len())?);
-        let metadata = Metadata::new(EntryMode::FILE).with_content_length(bs.len() as u64);
+        let metadata = {
+            let mut metadata = Metadata::builder(EntryMode::FILE);
+            metadata.content_length(bs.len() as u64);
+            metadata.build()
+        };
         Ok((
             RpRead::new(metadata),
             Box::new(content) as Box<dyn oio::ReadStreamDyn>,
diff --git a/core/services/memcached/src/writer.rs b/core/services/memcached/src/writer.rs
index bd5f0e4768..617be35edf 100644
--- a/core/services/memcached/src/writer.rs
+++ b/core/services/memcached/src/writer.rs
@@ -49,7 +49,11 @@ impl oio::Write for MemcachedWriter {
         let length = buf.len() as u64;
         self.core.set(&self.path, buf).await?;
 
-        let meta = Metadata::new(EntryMode::from_path(&self.path)).with_content_length(length);
+        let meta = {
+            let mut metadata = Metadata::builder(EntryMode::from_path(&self.path));
+            metadata.content_length(length);
+            metadata.build()
+        };
         Ok(meta)
     }
 
diff --git a/core/services/mini_moka/src/backend.rs b/core/services/mini_moka/src/backend.rs
index 66798b1d76..ff57933ad3 100644
--- a/core/services/mini_moka/src/backend.rs
+++ b/core/services/mini_moka/src/backend.rs
@@ -180,13 +180,13 @@ impl Service for MiniMokaBackend {
         // Check if path exists directly in cache
         match self.core.get(&p) {
             Some(value) => {
-                let mut metadata = value.metadata.clone();
+                let mut metadata = value.metadata.clone().into_builder();
                 if p.ends_with('/') {
-                    metadata.set_mode(EntryMode::DIR);
+                    metadata.mode(EntryMode::DIR);
                 } else {
-                    metadata.set_mode(EntryMode::FILE);
+                    metadata.mode(EntryMode::FILE);
                 }
-                Ok(RpStat::new(metadata))
+                Ok(RpStat::new(metadata.build()))
             }
             None => {
                 if p.ends_with('/') {
@@ -197,9 +197,9 @@ impl Service for MiniMokaBackend {
                         .any(|entry| entry.key().starts_with(&p) && entry.key() != &p);
 
                     if is_prefix {
-                        let mut metadata = Metadata::default();
-                        metadata.set_mode(EntryMode::DIR);
-                        return Ok(RpStat::new(metadata));
+                        let mut metadata = Metadata::builder(EntryMode::Unknown);
+                        metadata.mode(EntryMode::DIR);
+                        return Ok(RpStat::new(metadata.build()));
                     }
                 }
 
diff --git a/core/services/mini_moka/src/reader.rs b/core/services/mini_moka/src/reader.rs
index 572d8c30e3..20590a1ad3 100644
--- a/core/services/mini_moka/src/reader.rs
+++ b/core/services/mini_moka/src/reader.rs
@@ -46,7 +46,11 @@ impl oio::StreamRead for MiniMokaReader {
                 let sliced_content = value
                     .content
                     .slice(range.to_content_range(value.content.len())?);
-                let metadata = Metadata::new(EntryMode::FILE).with_content_length(total_size);
+                let metadata = {
+                    let mut metadata = Metadata::builder(EntryMode::FILE);
+                    metadata.content_length(total_size);
+                    metadata.build()
+                };
 
                 Ok((
                     RpRead::new(metadata),
diff --git a/core/services/mini_moka/src/writer.rs b/core/services/mini_moka/src/writer.rs
index 84fec5ccb2..1fac2b8676 100644
--- a/core/services/mini_moka/src/writer.rs
+++ b/core/services/mini_moka/src/writer.rs
@@ -49,24 +49,25 @@ impl oio::Write for MiniMokaWriter {
     async fn close(&mut self) -> Result<Metadata> {
         let buf = self.buffer.clone().collect();
 
-        let mut md = Metadata::new(EntryMode::from_path(&self.path));
-        md.set_content_length(buf.len() as u64);
-        md.set_last_modified(Timestamp::now());
+        let mut md = Metadata::builder(EntryMode::from_path(&self.path));
+        md.content_length(buf.len() as u64);
+        md.last_modified(Timestamp::now());
 
         // Set metadata from OpWrite
         if let Some(content_type) = self.op.content_type() {
-            md.set_content_type(content_type);
+            md.content_type(content_type);
         }
         if let Some(content_disposition) = self.op.content_disposition() {
-            md.set_content_disposition(content_disposition);
+            md.content_disposition(content_disposition);
         }
         if let Some(content_encoding) = self.op.content_encoding() {
-            md.set_content_encoding(content_encoding);
+            md.content_encoding(content_encoding);
         }
         if let Some(cache_control) = self.op.cache_control() {
-            md.set_cache_control(cache_control);
+            md.cache_control(cache_control);
         }
 
+        let md = md.build();
         let value = MiniMokaValue {
             metadata: md.clone(),
             content: buf,
diff --git a/core/services/moka/src/backend.rs b/core/services/moka/src/backend.rs
index e6b3d71129..9399e78c9b 100644
--- a/core/services/moka/src/backend.rs
+++ b/core/services/moka/src/backend.rs
@@ -251,19 +251,19 @@ impl Service for MokaBackend {
         let p = build_abs_path(&self.root, path);
 
         if p == build_abs_path(&self.root, "") {
-            Ok(RpStat::new(Metadata::new(EntryMode::DIR)))
+            Ok(RpStat::new(Metadata::builder(EntryMode::DIR).build()))
         } else {
             // Check the exact path first
             match self.core.get(&p).await? {
                 Some(value) => {
                     // Use the stored metadata but override mode if necessary
-                    let mut metadata = value.metadata.clone();
+                    let mut metadata = value.metadata.clone().into_builder();
                     // If path ends with '/' but we found a file, return DIR
                     // This is because CompleteLayer's create_dir creates empty files with '/' suffix
-                    if p.ends_with('/') && metadata.mode() != EntryMode::DIR {
-                        metadata.set_mode(EntryMode::DIR);
+                    if p.ends_with('/') && value.metadata.mode() != EntryMode::DIR {
+                        metadata.mode(EntryMode::DIR);
                     }
-                    Ok(RpStat::new(metadata))
+                    Ok(RpStat::new(metadata.build()))
                 }
                 None => {
                     // If path ends with '/', check if there are any children
@@ -275,7 +275,7 @@ impl Service for MokaBackend {
                             .any(|kv| kv.0.starts_with(&p) && kv.0.len() > p.len());
 
                         if has_children {
-                            Ok(RpStat::new(Metadata::new(EntryMode::DIR)))
+                            Ok(RpStat::new(Metadata::builder(EntryMode::DIR).build()))
                         } else {
                             Err(Error::new(ErrorKind::NotFound, "key not found in moka"))
                         }
diff --git a/core/services/moka/src/reader.rs b/core/services/moka/src/reader.rs
index ee1969ea8d..8a578f781c 100644
--- a/core/services/moka/src/reader.rs
+++ b/core/services/moka/src/reader.rs
@@ -46,7 +46,11 @@ impl oio::StreamRead for MokaReader {
                 let buffer = value
                     .content
                     .slice(range.to_content_range(value.content.len())?);
-                let metadata = Metadata::new(EntryMode::FILE).with_content_length(total_size);
+                let metadata = {
+                    let mut metadata = Metadata::builder(EntryMode::FILE);
+                    metadata.content_length(total_size);
+                    metadata.build()
+                };
                 Ok((
                     RpRead::new(metadata),
                     Box::new(buffer) as Box<dyn oio::ReadStreamDyn>,
diff --git a/core/services/moka/src/writer.rs b/core/services/moka/src/writer.rs
index 1a88b94b16..d87bf369f5 100644
--- a/core/services/moka/src/writer.rs
+++ b/core/services/moka/src/writer.rs
@@ -51,22 +51,23 @@ impl oio::Write for MokaWriter {
         let length = buf.len() as u64;
 
         // Build metadata with write options
-        let mut metadata =
-            Metadata::new(EntryMode::from_path(&self.path)).with_content_length(length);
+        let mut metadata = Metadata::builder(EntryMode::from_path(&self.path));
+        metadata.content_length(length);
 
         if let Some(content_type) = self.op.content_type() {
-            metadata.set_content_type(content_type);
+            metadata.content_type(content_type);
         }
         if let Some(content_disposition) = self.op.content_disposition() {
-            metadata.set_content_disposition(content_disposition);
+            metadata.content_disposition(content_disposition);
         }
         if let Some(cache_control) = self.op.cache_control() {
-            metadata.set_cache_control(cache_control);
+            metadata.cache_control(cache_control);
         }
         if let Some(content_encoding) = self.op.content_encoding() {
-            metadata.set_content_encoding(content_encoding);
+            metadata.content_encoding(content_encoding);
         }
 
+        let metadata = metadata.build();
         let value = MokaValue {
             metadata: metadata.clone(),
             content: buf,
diff --git a/core/services/mongodb/src/backend.rs b/core/services/mongodb/src/backend.rs
index 0d12205477..b101aabab1 100644
--- a/core/services/mongodb/src/backend.rs
+++ b/core/services/mongodb/src/backend.rs
@@ -239,12 +239,14 @@ impl Service for MongodbBackend {
         let p = build_abs_path(&self.root, path);
 
         if p == build_abs_path(&self.root, "") {
-            Ok(RpStat::new(Metadata::new(EntryMode::DIR)))
+            Ok(RpStat::new(Metadata::builder(EntryMode::DIR).build()))
         } else {
             match self.core.get_length(&p).await? {
-                Some(length) => Ok(RpStat::new(
-                    Metadata::new(EntryMode::FILE).with_content_length(length as u64),
-                )),
+                Some(length) => Ok(RpStat::new({
+                    let mut metadata = Metadata::builder(EntryMode::FILE);
+                    metadata.content_length(length as u64);
+                    metadata.build()
+                })),
                 None => Err(Error::new(ErrorKind::NotFound, "kv not found in mongodb")),
             }
         }
diff --git a/core/services/mongodb/src/reader.rs b/core/services/mongodb/src/reader.rs
index 9a391e58de..daad5e1660 100644
--- a/core/services/mongodb/src/reader.rs
+++ b/core/services/mongodb/src/reader.rs
@@ -46,7 +46,11 @@ impl oio::StreamRead for MongodbReader {
             }
         };
         let content = bs.slice(range.to_content_range(bs.len())?);
-        let metadata = Metadata::new(EntryMode::FILE).with_content_length(bs.len() as u64);
+        let metadata = {
+            let mut metadata = Metadata::builder(EntryMode::FILE);
+            metadata.content_length(bs.len() as u64);
+            metadata.build()
+        };
         Ok((
             RpRead::new(metadata),
             Box::new(content) as Box<dyn oio::ReadStreamDyn>,
diff --git a/core/services/mongodb/src/writer.rs b/core/services/mongodb/src/writer.rs
index fab1039972..8269b134e2 100644
--- a/core/services/mongodb/src/writer.rs
+++ b/core/services/mongodb/src/writer.rs
@@ -48,7 +48,11 @@ impl oio::Write for MongodbWriter {
         let length = buf.len() as u64;
         self.core.set(&self.path, buf).await?;
 
-        let meta = Metadata::new(EntryMode::from_path(&self.path)).with_content_length(length);
+        let meta = {
+            let mut metadata = Metadata::builder(EntryMode::from_path(&self.path));
+            metadata.content_length(length);
+            metadata.build()
+        };
         Ok(meta)
     }
 
diff --git a/core/services/monoiofs/src/backend.rs b/core/services/monoiofs/src/backend.rs
index ba662e0daf..56d99334e2 100644
--- a/core/services/monoiofs/src/backend.rs
+++ b/core/services/monoiofs/src/backend.rs
@@ -120,12 +120,12 @@ impl Service for MonoiofsBackend {
         } else {
             EntryMode::Unknown
         };
-        let m = Metadata::new(mode)
-            .with_content_length(meta.len())
-            .with_last_modified(Timestamp::try_from(
+        let mut m = Metadata::builder(mode);
+        m.content_length(meta.len())
+            .last_modified(Timestamp::try_from(
                 meta.modified().map_err(new_std_io_error)?,
             )?);
-        Ok(RpStat::new(m))
+        Ok(RpStat::new(m.build()))
     }
     fn read(&self, _ctx: &OperationContext, path: &str, _args: OpRead) -> Result<Self::Reader> {
         let path = self.core.prepare_path(path)?;
@@ -255,7 +255,7 @@ impl Service for MonoiofsBackend {
             })
             .await
             .map_err(new_std_io_error)?;
-            Ok(Metadata::default())
+            Ok(Metadata::builder(EntryMode::Unknown).build())
         });
 
         Ok(copier)
diff --git a/core/services/monoiofs/src/writer.rs b/core/services/monoiofs/src/writer.rs
index 710fc1f5b0..85f60da9ac 100644
--- a/core/services/monoiofs/src/writer.rs
+++ b/core/services/monoiofs/src/writer.rs
@@ -160,12 +160,12 @@ impl oio::Write for MonoiofsWriter {
         } else {
             EntryMode::Unknown
         };
-        let meta = Metadata::new(mode)
-            .with_content_length(file_meta.len())
-            .with_last_modified(Timestamp::try_from(
+        let mut meta = Metadata::builder(mode);
+        meta.content_length(file_meta.len())
+            .last_modified(Timestamp::try_from(
                 file_meta.modified().map_err(new_std_io_error)?,
             )?);
-        Ok(meta)
+        Ok(meta.build())
     }
 
     async fn abort(&mut self) -> Result<()> {
diff --git a/core/services/mysql/src/backend.rs b/core/services/mysql/src/backend.rs
index 66b8c2d0c0..63d2d83c5b 100644
--- a/core/services/mysql/src/backend.rs
+++ b/core/services/mysql/src/backend.rs
@@ -220,12 +220,14 @@ impl Service for MysqlBackend {
         let p = build_abs_path(&self.root, path);
 
         if p == build_abs_path(&self.root, "") {
-            Ok(RpStat::new(Metadata::new(EntryMode::DIR)))
+            Ok(RpStat::new(Metadata::builder(EntryMode::DIR).build()))
         } else {
             match self.core.get_length(&p).await? {
-                Some(length) => Ok(RpStat::new(
-                    Metadata::new(EntryMode::FILE).with_content_length(length as u64),
-                )),
+                Some(length) => Ok(RpStat::new({
+                    let mut metadata = Metadata::builder(EntryMode::FILE);
+                    metadata.content_length(length as u64);
+                    metadata.build()
+                })),
                 None => Err(Error::new(ErrorKind::NotFound, "kv not found in mysql")),
             }
         }
diff --git a/core/services/mysql/src/lister.rs b/core/services/mysql/src/lister.rs
index 963e729245..07d293d452 100644
--- a/core/services/mysql/src/lister.rs
+++ b/core/services/mysql/src/lister.rs
@@ -47,7 +47,7 @@ impl List for MysqlLister {
         if path.is_empty() {
             path = "/".to_string();
         }
-        let meta = Metadata::new(EntryMode::from_path(&path));
+        let meta = Metadata::builder(EntryMode::from_path(&path)).build();
         Ok(Some(Entry::new(&path, meta)))
     }
 }
diff --git a/core/services/mysql/src/reader.rs b/core/services/mysql/src/reader.rs
index e80de0983a..41fd321e03 100644
--- a/core/services/mysql/src/reader.rs
+++ b/core/services/mysql/src/reader.rs
@@ -45,7 +45,11 @@ impl oio::StreamRead for MysqlReader {
             None => return Err(Error::new(ErrorKind::NotFound, "kv not found in mysql")),
         };
         let content = bs.slice(range.to_content_range(bs.len())?);
-        let metadata = Metadata::new(EntryMode::FILE).with_content_length(bs.len() as u64);
+        let metadata = {
+            let mut metadata = Metadata::builder(EntryMode::FILE);
+            metadata.content_length(bs.len() as u64);
+            metadata.build()
+        };
         Ok((
             RpRead::new(metadata),
             Box::new(content) as Box<dyn oio::ReadStreamDyn>,
diff --git a/core/services/mysql/src/writer.rs b/core/services/mysql/src/writer.rs
index 7473412f5f..208f33a5c8 100644
--- a/core/services/mysql/src/writer.rs
+++ b/core/services/mysql/src/writer.rs
@@ -48,7 +48,11 @@ impl oio::Write for MysqlWriter {
         let length = buf.len() as u64;
         self.core.set(&self.path, buf).await?;
 
-        let meta = Metadata::new(EntryMode::from_path(&self.path)).with_content_length(length);
+        let meta = {
+            let mut metadata = Metadata::builder(EntryMode::from_path(&self.path));
+            metadata.content_length(length);
+            metadata.build()
+        };
         Ok(meta)
     }
 
diff --git a/core/services/obs/src/backend.rs b/core/services/obs/src/backend.rs
index b43c0635cc..b204b9f5f8 100644
--- a/core/services/obs/src/backend.rs
+++ b/core/services/obs/src/backend.rs
@@ -301,7 +301,7 @@ impl Service for ObsBackend {
         // The response is very similar to azblob.
         match status {
             StatusCode::OK => {
-                let mut meta = parse_into_metadata(path, headers)?;
+                let meta = parse_into_metadata(path, headers)?;
                 let user_meta = headers
                     .iter()
                     .filter_map(|(name, _)| {
@@ -315,18 +315,19 @@ impl Service for ObsBackend {
                     })
                     .collect::<HashMap<_, _>>();
 
+                let mut meta = meta.into_builder();
                 if !user_meta.is_empty() {
-                    meta = meta.with_user_metadata(user_meta);
+                    meta.user_metadata(user_meta);
                 }
 
                 if let Some(v) = parse_header_to_str(headers, constants::X_OBS_VERSION_ID)? {
-                    meta.set_version(v);
+                    meta.version(v);
                 }
 
-                Ok(RpStat::new(meta))
+                Ok(RpStat::new(meta.build()))
             }
             StatusCode::NOT_FOUND if path.ends_with('/') => {
-                Ok(RpStat::new(Metadata::new(EntryMode::DIR)))
+                Ok(RpStat::new(Metadata::builder(EntryMode::DIR).build()))
             }
             _ => Err(parse_error(
                 ErrorContext::new(ServiceOperation("HeadObject")),
@@ -410,7 +411,7 @@ impl Service for ObsBackend {
             let status = resp.status();
 
             match status {
-                StatusCode::OK => Ok(Metadata::default()),
+                StatusCode::OK => Ok(Metadata::builder(EntryMode::Unknown).build()),
                 _ => Err(parse_error(
                     ErrorContext::new(ServiceOperation("CopyObject")),
                     resp,
diff --git a/core/services/obs/src/lister.rs b/core/services/obs/src/lister.rs
index 08c49ea95e..8de2cf4abf 100644
--- a/core/services/obs/src/lister.rs
+++ b/core/services/obs/src/lister.rs
@@ -95,7 +95,7 @@ impl oio::PageList for ObsLister {
         for prefix in common_prefixes {
             let de = oio::Entry::new(
                 &build_rel_path(&self.core.root, &prefix.prefix),
-                Metadata::new(EntryMode::DIR),
+                Metadata::builder(EntryMode::DIR).build(),
             );
 
             ctx.entries.push_back(de);
@@ -107,7 +107,11 @@ impl oio::PageList for ObsLister {
                 path = "/".to_string();
             }
 
-            let meta = Metadata::new(EntryMode::from_path(&path)).with_content_length(object.size);
+            let meta = {
+                let mut metadata = Metadata::builder(EntryMode::from_path(&path));
+                metadata.content_length(object.size);
+                metadata.build()
+            };
 
             let de = oio::Entry::with(path, meta);
 
diff --git a/core/services/obs/src/writer.rs b/core/services/obs/src/writer.rs
index e0f99789c5..3a92cd19e0 100644
--- a/core/services/obs/src/writer.rs
+++ b/core/services/obs/src/writer.rs
@@ -48,18 +48,18 @@ impl ObsWriter {
     }
 
     fn parse_metadata(headers: &HeaderMap<HeaderValue>) -> Result<Metadata> {
-        let mut meta = Metadata::default();
+        let mut meta = Metadata::builder(EntryMode::Unknown);
         if let Some(etag) = parse_etag(headers)? {
-            meta.set_etag(etag);
+            meta.etag(etag);
         }
         if let Some(md5) = parse_content_md5(headers)? {
-            meta.set_content_md5(md5);
+            meta.content_md5(md5);
         }
         if let Some(version) = parse_header_to_str(headers, constants::X_OBS_VERSION_ID)? {
-            meta.set_version(version);
+            meta.version(version);
         }
 
-        Ok(meta)
+        Ok(meta.build())
     }
 }
 
@@ -178,17 +178,17 @@ impl oio::MultipartWrite for ObsWriter {
             .obs_complete_multipart_upload(&self.ctx, &self.path, upload_id, parts)
             .await?;
 
-        let mut meta = Self::parse_metadata(resp.headers())?;
+        let mut meta = Self::parse_metadata(resp.headers())?.into_builder();
 
         let result: CompleteMultipartUploadResult =
             quick_xml::de::from_reader(resp.body_mut().reader())
                 .map_err(new_xml_deserialize_error)?;
-        meta.set_etag(&result.etag);
+        meta.etag(&result.etag);
 
         let status = resp.status();
 
         match status {
-            StatusCode::OK => Ok(meta),
+            StatusCode::OK => Ok(meta.build()),
             _ => Err(parse_error(
                 ErrorContext::new(ServiceOperation("CompleteMultipartUpload")),
                 resp,
@@ -248,18 +248,18 @@ impl oio::AppendWrite for ObsWriter {
 
         let resp = self.core.send(&self.ctx, req).await?;
 
-        let mut meta = Metadata::default();
+        let mut meta = Metadata::builder(EntryMode::Unknown);
         if let Some(md5) = parse_content_md5(resp.headers())? {
-            meta.set_content_md5(md5);
+            meta.content_md5(md5);
         }
         if let Some(version) = parse_header_to_str(resp.headers(), constants::X_OBS_VERSION_ID)? {
-            meta.set_version(version);
+            meta.version(version);
         }
 
         let status = resp.status();
 
         match status {
-            StatusCode::OK => Ok(meta),
+            StatusCode::OK => Ok(meta.build()),
             _ => Err(parse_error(
                 ErrorContext::new(ServiceOperation("AppendObject")),
                 resp,
diff --git a/core/services/onedrive/src/backend.rs b/core/services/onedrive/src/backend.rs
index 68482d95e1..acc38d12c5 100644
--- a/core/services/onedrive/src/backend.rs
+++ b/core/services/onedrive/src/backend.rs
@@ -310,7 +310,7 @@ impl Service for OnedriveBackend {
         Ok(oio::OneShotCopier::new(async move {
             let monitor_url = core.initialize_copy(&ctx, &from, &to).await?;
             core.wait_until_complete(&ctx, monitor_url).await?;
-            Ok(Metadata::default())
+            Ok(Metadata::builder(EntryMode::Unknown).build())
         }))
     }
 
diff --git a/core/services/onedrive/src/core.rs b/core/services/onedrive/src/core.rs
index 938f0aa841..2429e73b72 100644
--- a/core/services/onedrive/src/core.rs
+++ b/core/services/onedrive/src/core.rs
@@ -213,15 +213,15 @@ impl OneDriveCore {
             ItemType::File { .. } => EntryMode::FILE,
         };
 
-        let mut meta = Metadata::new(entry_mode)
-            .with_etag(decoded_response.e_tag)
-            .with_content_length(decoded_response.size.max(0) as u64);
+        let mut meta = Metadata::builder(entry_mode);
+        meta.etag(decoded_response.e_tag)
+            .content_length(decoded_response.size.max(0) as u64);
 
         let last_modified = decoded_response.last_modified_date_time;
         let date_utc_last_modified = last_modified.parse::<Timestamp>()?;
-        meta.set_last_modified(date_utc_last_modified);
+        meta.last_modified(date_utc_last_modified);
 
-        Ok(meta)
+        Ok(meta.build())
     }
 
     /// Return versions of an item
diff --git a/core/services/onedrive/src/lister.rs b/core/services/onedrive/src/lister.rs
index 20d78979e5..f6f33dfedb 100644
--- a/core/services/onedrive/src/lister.rs
+++ b/core/services/onedrive/src/lister.rs
@@ -141,11 +141,12 @@ impl oio::PageList for OneDriveLister {
                 continue;
             }
 
-            let mut meta = Metadata::new(entry_mode)
-                .with_etag(drive_item.e_tag)
-                .with_content_length(drive_item.size.max(0) as u64);
+            let mut meta = Metadata::builder(entry_mode);
+            meta.etag(drive_item.e_tag)
+                .content_length(drive_item.size.max(0) as u64);
             let last_modified = drive_item.last_modified_date_time.parse::<Timestamp>()?;
-            meta.set_last_modified(last_modified);
+            meta.last_modified(last_modified);
+            let meta = meta.build();
 
             // OneDrive doesn't support expanding versions while listing a directory.
             // Query each file separately when callers request versions.
@@ -162,20 +163,20 @@ impl oio::PageList for OneDriveLister {
                 }
 
                 for (index, version) in versions.into_iter().enumerate() {
-                    let mut version_meta =
-                        Metadata::new(entry_mode).with_content_length(version.size.max(0) as u64);
+                    let mut version_meta = Metadata::builder(entry_mode);
+                    version_meta.content_length(version.size.max(0) as u64);
                     version_meta
-                        .set_last_modified(version.last_modified_date_time.parse::<Timestamp>()?);
-                    version_meta.set_version(&version.id);
-                    version_meta.set_is_current(index == 0);
+                        .last_modified(version.last_modified_date_time.parse::<Timestamp>()?);
+                    version_meta.version(&version.id);
+                    version_meta.is_current(Some(index == 0));
 
                     // OneDrive exposes the ETag only for the current item.
                     if index == 0 {
-                        version_meta.set_etag(meta.etag().unwrap_or_default());
+                        version_meta.etag(meta.etag().unwrap_or_default());
                     }
 
                     ctx.entries
-                        .push_back(oio::Entry::new(&normalized_path, version_meta));
+                        .push_back(oio::Entry::new(&normalized_path, version_meta.build()));
                 }
             } else {
                 ctx.entries
diff --git a/core/services/onedrive/src/writer.rs b/core/services/onedrive/src/writer.rs
index c7b7325719..2a4f60e9e9 100644
--- a/core/services/onedrive/src/writer.rs
+++ b/core/services/onedrive/src/writer.rs
@@ -82,15 +82,15 @@ impl OneDriveWriter {
                 let item: OneDriveItem = serde_json::from_reader(response.into_body().reader())
                     .map_err(new_json_deserialize_error)?;
 
-                let mut meta = Metadata::new(EntryMode::FILE)
-                    .with_etag(item.e_tag)
-                    .with_content_length(item.size.max(0) as u64);
+                let mut meta = Metadata::builder(EntryMode::FILE);
+                meta.etag(item.e_tag)
+                    .content_length(item.size.max(0) as u64);
 
                 let last_modified = item.last_modified_date_time;
                 let date_utc_last_modified = last_modified.parse::<Timestamp>()?;
-                meta.set_last_modified(date_utc_last_modified);
+                meta.last_modified(date_utc_last_modified);
 
-                Ok(meta)
+                Ok(meta.build())
             }
             _ => Err(parse_error(
                 ErrorContext::new(ServiceOperation("UploadContent")),
@@ -141,14 +141,14 @@ impl OneDriveWriter {
                     let item: OneDriveItem = serde_json::from_reader(response.into_body().reader())
                         .map_err(new_json_deserialize_error)?;
 
-                    let mut meta = Metadata::new(EntryMode::FILE)
-                        .with_etag(item.e_tag)
-                        .with_content_length(item.size.max(0) as u64);
+                    let mut meta = Metadata::builder(EntryMode::FILE);
+                    meta.etag(item.e_tag)
+                        .content_length(item.size.max(0) as u64);
 
                     let last_modified = item.last_modified_date_time;
                     let date_utc_last_modified = last_modified.parse::<Timestamp>()?;
-                    meta.set_last_modified(date_utc_last_modified);
-                    return Ok(meta);
+                    meta.last_modified(date_utc_last_modified);
+                    return Ok(meta.build());
                 }
                 _ => {
                     return Err(parse_error(
@@ -163,7 +163,7 @@ impl OneDriveWriter {
 
         debug_assert!(false, "should have returned");
 
-        Ok(Metadata::default()) // should not happen, but start with handling this gracefully - do nothing, but return the default metadata
+        Ok(Metadata::builder(EntryMode::Unknown).build()) // should not happen, but start with handling this gracefully - do nothing, but return the default metadata
     }
 
     async fn create_upload_session(&self) -> Result<OneDriveUploadSessionCreationResponseBody> {
diff --git a/core/services/opfs/src/backend.rs b/core/services/opfs/src/backend.rs
index f1dda3be20..7717063712 100644
--- a/core/services/opfs/src/backend.rs
+++ b/core/services/opfs/src/backend.rs
@@ -87,7 +87,7 @@ impl Service for OpfsBackend {
 
         if p.ends_with('/') {
             get_directory_handle(&p, false).await?;
-            return Ok(RpStat::new(Metadata::new(EntryMode::DIR)));
+            return Ok(RpStat::new(Metadata::builder(EntryMode::DIR).build()));
         }
 
         // File: get metadata via getFile().
@@ -97,10 +97,10 @@ impl Service for OpfsBackend {
             .and_then(JsCast::dyn_into)
             .map_err(parse_js_error)?;
 
-        let mut meta = Metadata::new(EntryMode::FILE);
-        meta.set_content_length(file.size() as u64);
+        let mut meta = Metadata::builder(EntryMode::FILE);
+        meta.content_length(file.size() as u64);
         if let Ok(t) = Timestamp::from_millisecond(file.last_modified() as i64) {
-            meta.set_last_modified(t);
+            meta.last_modified(t);
         }
 
         Ok(RpStat::new(meta))
diff --git a/core/services/opfs/src/lister.rs b/core/services/opfs/src/lister.rs
index 0a113c5014..4415024969 100644
--- a/core/services/opfs/src/lister.rs
+++ b/core/services/opfs/src/lister.rs
@@ -94,6 +94,9 @@ impl oio::List for OpfsLister {
             (format!("{}{}", self.path, name), EntryMode::FILE)
         };
 
-        Ok(Some(oio::Entry::new(&entry_path, Metadata::new(mode))))
+        Ok(Some(oio::Entry::new(
+            &entry_path,
+            Metadata::builder(mode).build(),
+        )))
     }
 }
diff --git a/core/services/opfs/src/writer.rs b/core/services/opfs/src/writer.rs
index 2242b7f3cf..8c394a52b7 100644
--- a/core/services/opfs/src/writer.rs
+++ b/core/services/opfs/src/writer.rs
@@ -101,8 +101,8 @@ impl oio::Write for OpfsWriter {
         }
 
         // We cannot set LastModified here - stream does not have such metadata
-        let mut meta = Metadata::new(EntryMode::FILE);
-        meta.set_content_length(self.bytes_written);
+        let mut meta = Metadata::builder(EntryMode::FILE);
+        meta.content_length(self.bytes_written);
         Ok(meta)
     }
 
diff --git a/core/services/oss/src/backend.rs b/core/services/oss/src/backend.rs
index afb3bd66c5..3eca50c25e 100644
--- a/core/services/oss/src/backend.rs
+++ b/core/services/oss/src/backend.rs
@@ -672,13 +672,16 @@ impl Service for OssBackend {
         match status {
             StatusCode::OK => {
                 let headers = resp.headers();
-                let mut meta = self.core.parse_metadata(path, resp.headers())?;
+                let mut meta = self
+                    .core
+                    .parse_metadata(path, resp.headers())?
+                    .into_builder();
 
                 if let Some(v) = parse_header_to_str(headers, constants::X_OSS_VERSION_ID)? {
-                    meta.set_version(v);
+                    meta.version(v);
                 }
 
-                Ok(RpStat::new(meta))
+                Ok(RpStat::new(meta.build()))
             }
             _ => Err(parse_error(
                 ErrorContext::new(ServiceOperation("HeadObject")),
@@ -772,7 +775,7 @@ impl Service for OssBackend {
             let status = resp.status();
 
             match status {
-                StatusCode::OK => Ok(Metadata::default()),
+                StatusCode::OK => Ok(Metadata::builder(EntryMode::Unknown).build()),
                 _ => Err(parse_error(
                     ErrorContext::new(ServiceOperation("CopyObject")),
                     resp,
diff --git a/core/services/oss/src/core.rs b/core/services/oss/src/core.rs
index c6adf94490..3c99cfa2ca 100644
--- a/core/services/oss/src/core.rs
+++ b/core/services/oss/src/core.rs
@@ -240,13 +240,13 @@ impl OssCore {
     ///
     /// before return the user defined metadata, we'll strip the user_metadata_prefix from the key
     pub fn parse_metadata(&self, path: &str, headers: &HeaderMap) -> Result<Metadata> {
-        let mut m = parse_into_metadata(path, headers)?;
+        let mut m = parse_into_metadata(path, headers)?.into_builder();
         let user_meta = parse_prefixed_headers(headers, X_OSS_META_PREFIX);
         if !user_meta.is_empty() {
-            m = m.with_user_metadata(user_meta);
+            m.user_metadata(user_meta);
         }
 
-        Ok(m)
+        Ok(m.build())
     }
 }
 
diff --git a/core/services/oss/src/deleter.rs b/core/services/oss/src/deleter.rs
index 9fdad8b346..1d897b56fb 100644
--- a/core/services/oss/src/deleter.rs
+++ b/core/services/oss/src/deleter.rs
@@ -94,10 +94,11 @@ impl oio::BatchDelete for OssDeleter {
 
         for i in result.deleted {
             let path = build_rel_path(&self.core.root, &i.key);
-            let mut op = OpDelete::default();
-            if let Some(version) = &i.version_id {
-                op = op.with_version(version);
+            let op = options::DeleteOptions {
+                version: i.version_id,
+                ..Default::default()
             }
+            .into();
             let object = (path, op);
             keys.remove(&object);
             batched_result.succeeded.push(object);
diff --git a/core/services/oss/src/lister.rs b/core/services/oss/src/lister.rs
index 1ff8c54f5d..00b7ba83f5 100644
--- a/core/services/oss/src/lister.rs
+++ b/core/services/oss/src/lister.rs
@@ -97,7 +97,7 @@ impl oio::PageList for OssLister {
         for prefix in output.common_prefixes {
             let de = oio::Entry::new(
                 &build_rel_path(&self.core.root, &prefix.prefix),
-                Metadata::new(EntryMode::DIR),
+                Metadata::builder(EntryMode::DIR).build(),
             );
             ctx.entries.push_back(de);
         }
@@ -111,14 +111,14 @@ impl oio::PageList for OssLister {
                 continue;
             }
 
-            let mut meta = Metadata::new(EntryMode::from_path(&path));
-            meta.set_is_current(true);
-            meta.set_etag(&object.etag);
-            meta.set_content_md5(object.etag.trim_matches('"'));
-            meta.set_content_length(object.size);
-            meta.set_last_modified(object.last_modified.parse::<Timestamp>()?);
+            let mut meta = Metadata::builder(EntryMode::from_path(&path));
+            meta.is_current(Some(true));
+            meta.etag(&object.etag);
+            meta.content_md5(object.etag.trim_matches('"'));
+            meta.content_length(object.size);
+            meta.last_modified(object.last_modified.parse::<Timestamp>()?);
 
-            let de = oio::Entry::with(path, meta);
+            let de = oio::Entry::with(path, meta.build());
             ctx.entries.push_back(de);
         }
 
@@ -209,7 +209,7 @@ impl oio::PageList for OssObjectVersionsLister {
         for prefix in output.common_prefixes {
             let de = oio::Entry::new(
                 &build_rel_path(&self.core.root, &prefix.prefix),
-                Metadata::new(EntryMode::DIR),
+                Metadata::builder(EntryMode::DIR).build(),
             );
             ctx.entries.push_back(de);
         }
@@ -228,17 +228,17 @@ impl oio::PageList for OssObjectVersionsLister {
                 path = "/".to_owned();
             }
 
-            let mut meta = Metadata::new(EntryMode::from_path(&path));
-            meta.set_version(&version_object.version_id);
-            meta.set_is_current(version_object.is_latest);
-            meta.set_content_length(version_object.size);
-            meta.set_last_modified(version_object.last_modified.parse::<Timestamp>()?);
+            let mut meta = Metadata::builder(EntryMode::from_path(&path));
+            meta.version(&version_object.version_id);
+            meta.is_current(Some(version_object.is_latest));
+            meta.content_length(version_object.size);
+            meta.last_modified(version_object.last_modified.parse::<Timestamp>()?);
             if let Some(etag) = version_object.etag {
-                meta.set_etag(&etag);
-                meta.set_content_md5(etag.trim_matches('"'));
+                meta.etag(&etag);
+                meta.content_md5(etag.trim_matches('"'));
             }
 
-            let entry = oio::Entry::new(&path, meta);
+            let entry = oio::Entry::new(&path, meta.build());
             ctx.entries.push_back(entry);
         }
 
@@ -249,13 +249,13 @@ impl oio::PageList for OssObjectVersionsLister {
                     path = "/".to_owned();
                 }
 
-                let mut meta = Metadata::new(EntryMode::FILE);
-                meta.set_version(&delete_marker.version_id);
-                meta.set_is_deleted(true);
-                meta.set_is_current(delete_marker.is_latest);
-                meta.set_last_modified(delete_marker.last_modified.parse::<Timestamp>()?);
+                let mut meta = Metadata::builder(EntryMode::FILE);
+                meta.version(&delete_marker.version_id);
+                meta.is_deleted(true);
+                meta.is_current(Some(delete_marker.is_latest));
... 2169 lines suppressed ...