diff --git a/CMakeLists.txt b/CMakeLists.txt
index 7f5d01971..cd03262b2 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -204,6 +204,7 @@ set(Z_FEATURE_MULTICAST_TRANSPORT 1 CACHE STRING "Toggle multicast transport")
 set(Z_FEATURE_UNICAST_TRANSPORT 1 CACHE STRING "Toggle unicast transport")
 set(Z_FEATURE_RAWETH_TRANSPORT 0 CACHE STRING "Toggle raw ethernet transport")
 set(Z_FEATURE_TCP_NODELAY 1 CACHE STRING "Toggle TCP_NODELAY")
+set(Z_FEATURE_LOCAL_SUBSCRIBER 0 CACHE STRING "Toggle local subscriptions")
 
 add_compile_definitions("Z_BUILD_DEBUG=$<CONFIG:Debug>")
 message(STATUS "Building with feature confing:\n\
diff --git a/include/zenoh-pico/collections/bytes.h b/include/zenoh-pico/collections/bytes.h
index b662ff613..2496520c1 100644
--- a/include/zenoh-pico/collections/bytes.h
+++ b/include/zenoh-pico/collections/bytes.h
@@ -45,8 +45,9 @@ typedef struct {
     _z_arc_slice_svec_t _slices;
 } _z_bytes_t;
 
+// Warning: None of the sub-types require a non-0 initialization. Add a init function if it changes.
+static inline _z_bytes_t _z_bytes_null(void) { return (_z_bytes_t){0}; }
 bool _z_bytes_check(const _z_bytes_t *bytes);
-_z_bytes_t _z_bytes_null(void);
 z_result_t _z_bytes_append_bytes(_z_bytes_t *dst, _z_bytes_t *src);
 z_result_t _z_bytes_append_slice(_z_bytes_t *dst, _z_arc_slice_t *s);
 z_result_t _z_bytes_copy(_z_bytes_t *dst, const _z_bytes_t *src);
diff --git a/include/zenoh-pico/collections/slice.h b/include/zenoh-pico/collections/slice.h
index 8027f6b1c..b6b6f45a5 100644
--- a/include/zenoh-pico/collections/slice.h
+++ b/include/zenoh-pico/collections/slice.h
@@ -26,9 +26,13 @@ typedef struct {
     void *context;
 } _z_delete_context_t;
 
-_z_delete_context_t _z_delete_context_null(void);
+// Warning: None of the sub-types require a non-0 initialization. Add a init function if it changes.
+static inline _z_delete_context_t _z_delete_context_null(void) { return (_z_delete_context_t){0}; }
+
+static inline _z_delete_context_t _z_delete_context_create(void (*deleter)(void *context, void *data), void *context) {
+    return (_z_delete_context_t){.deleter = deleter, .context = context};
+}
 bool _z_delete_context_is_null(const _z_delete_context_t *c);
-_z_delete_context_t _z_delete_context_create(void (*deleter)(void *context, void *data), void *context);
 _z_delete_context_t _z_delete_context_default(void);
 void _z_delete_context_delete(_z_delete_context_t *c, void *data);
 
@@ -47,21 +51,23 @@ typedef struct {
     _z_delete_context_t _delete_context;
 } _z_slice_t;
 
-_z_slice_t _z_slice_empty(void);
-inline static bool _z_slice_check(const _z_slice_t *slice) { return slice->start != NULL; }
+static inline _z_slice_t _z_slice_empty(void) { return (_z_slice_t){0}; }
+static inline bool _z_slice_is_empty(const _z_slice_t *bs) { return bs->len == 0; }
+static inline bool _z_slice_check(const _z_slice_t *slice) { return slice->start != NULL; }
+static inline _z_slice_t _z_slice_alias(const _z_slice_t bs) {
+    return (_z_slice_t){.len = bs.len, .start = bs.start, ._delete_context = _z_delete_context_null()};
+}
 z_result_t _z_slice_init(_z_slice_t *bs, size_t capacity);
 _z_slice_t _z_slice_make(size_t capacity);
 _z_slice_t _z_slice_alias_buf(const uint8_t *bs, size_t len);
 _z_slice_t _z_slice_from_buf_custom_deleter(const uint8_t *p, size_t len, _z_delete_context_t dc);
 _z_slice_t _z_slice_copy_from_buf(const uint8_t *bs, size_t len);
 _z_slice_t _z_slice_steal(_z_slice_t *b);
-_z_slice_t _z_slice_alias(const _z_slice_t *bs);
 z_result_t _z_slice_copy(_z_slice_t *dst, const _z_slice_t *src);
 z_result_t _z_slice_n_copy(_z_slice_t *dst, const _z_slice_t *src, size_t offset, size_t len);
 _z_slice_t _z_slice_duplicate(const _z_slice_t *src);
 void _z_slice_move(_z_slice_t *dst, _z_slice_t *src);
 void _z_slice_reset(_z_slice_t *bs);
-bool _z_slice_is_empty(const _z_slice_t *bs);
 bool _z_slice_eq(const _z_slice_t *left, const _z_slice_t *right);
 void _z_slice_clear(_z_slice_t *bs);
 void _z_slice_free(_z_slice_t **bs);
diff --git a/include/zenoh-pico/collections/string.h b/include/zenoh-pico/collections/string.h
index f2ebd15ac..167604774 100644
--- a/include/zenoh-pico/collections/string.h
+++ b/include/zenoh-pico/collections/string.h
@@ -66,8 +66,13 @@ typedef struct {
     _z_slice_t _slice;
 } _z_string_t;
 
-_z_string_t _z_string_null(void);
-bool _z_string_check(const _z_string_t *value);
+// Warning: None of the sub-types require a non-0 initialization. Add a init function if it changes.
+static inline _z_string_t _z_string_null(void) { return (_z_string_t){0}; }
+static inline bool _z_string_check(const _z_string_t *value) { return !_z_slice_is_empty(&value->_slice); }
+static inline _z_string_t _z_string_alias(const _z_string_t str) {
+    return (_z_string_t){._slice = _z_slice_alias(str._slice)};
+}
+
 _z_string_t _z_string_copy_from_str(const char *value);
 _z_string_t _z_string_copy_from_substr(const char *value, size_t len);
 _z_string_t *_z_string_copy_from_str_as_ptr(const char *value);
@@ -84,7 +89,6 @@ z_result_t _z_string_copy(_z_string_t *dst, const _z_string_t *src);
 z_result_t _z_string_copy_substring(_z_string_t *dst, const _z_string_t *src, size_t offset, size_t len);
 void _z_string_move(_z_string_t *dst, _z_string_t *src);
 _z_string_t _z_string_steal(_z_string_t *str);
-_z_string_t _z_string_alias(const _z_string_t *str);
 void _z_string_move_str(_z_string_t *dst, char *src);
 void _z_string_clear(_z_string_t *s);
 void _z_string_free(_z_string_t **s);
diff --git a/include/zenoh-pico/config.h b/include/zenoh-pico/config.h
index b3c5d3ec1..8ee4cf966 100644
--- a/include/zenoh-pico/config.h
+++ b/include/zenoh-pico/config.h
@@ -42,6 +42,7 @@
 #define Z_FEATURE_FRAGMENTATION 1
 #define Z_FEATURE_ENCODING_VALUES 1
 #define Z_FEATURE_TCP_NODELAY 1
+#define Z_FEATURE_LOCAL_SUBSCRIBER 0
 // End of CMake generation
 
 /*------------------ Runtime configuration properties ------------------*/
diff --git a/include/zenoh-pico/config.h.in b/include/zenoh-pico/config.h.in
index 40941d9fa..74ac25194 100644
--- a/include/zenoh-pico/config.h.in
+++ b/include/zenoh-pico/config.h.in
@@ -42,6 +42,7 @@
 #define Z_FEATURE_FRAGMENTATION @Z_FEATURE_FRAGMENTATION@
 #define Z_FEATURE_ENCODING_VALUES @Z_FEATURE_ENCODING_VALUES@
 #define Z_FEATURE_TCP_NODELAY @Z_FEATURE_TCP_NODELAY@
+#define Z_FEATURE_LOCAL_SUBSCRIBER @Z_FEATURE_LOCAL_SUBSCRIBER@
 // End of CMake generation
 
 /*------------------ Runtime configuration properties ------------------*/
diff --git a/include/zenoh-pico/net/encoding.h b/include/zenoh-pico/net/encoding.h
index 88ac5f0d1..969f0c34e 100644
--- a/include/zenoh-pico/net/encoding.h
+++ b/include/zenoh-pico/net/encoding.h
@@ -27,11 +27,14 @@ typedef struct _z_encoding_t {
     uint16_t id;
 } _z_encoding_t;
 
-z_result_t _z_encoding_make(_z_encoding_t *encoding, uint16_t id, const char *schema, size_t len);
+// Warning: None of the sub-types require a non-0 initialization. Add a init function if it changes.
+static inline _z_encoding_t _z_encoding_null(void) { return (_z_encoding_t){0}; }
+static inline bool _z_encoding_check(const _z_encoding_t *encoding) {
+    return ((encoding->id != _Z_ENCODING_ID_DEFAULT) || _z_string_check(&encoding->schema));
+}
 _z_encoding_t _z_encoding_wrap(uint16_t id, const char *schema);
-_z_encoding_t _z_encoding_null(void);
+z_result_t _z_encoding_make(_z_encoding_t *encoding, uint16_t id, const char *schema, size_t len);
 void _z_encoding_clear(_z_encoding_t *encoding);
-bool _z_encoding_check(const _z_encoding_t *encoding);
 z_result_t _z_encoding_copy(_z_encoding_t *dst, const _z_encoding_t *src);
 void _z_encoding_move(_z_encoding_t *dst, _z_encoding_t *src);
 _z_encoding_t _z_encoding_steal(_z_encoding_t *val);
diff --git a/include/zenoh-pico/net/publish.h b/include/zenoh-pico/net/publish.h
index 21a8b500f..b3bc40891 100644
--- a/include/zenoh-pico/net/publish.h
+++ b/include/zenoh-pico/net/publish.h
@@ -37,10 +37,11 @@ typedef struct _z_publisher_t {
 } _z_publisher_t;
 
 #if Z_FEATURE_PUBLICATION == 1
+// Warning: None of the sub-types require a non-0 initialization. Add a init function if it changes.
+static inline _z_publisher_t _z_publisher_null(void) { return (_z_publisher_t){0}; }
+static inline bool _z_publisher_check(const _z_publisher_t *publisher) { return !_Z_RC_IS_NULL(&publisher->_zn); }
 void _z_publisher_clear(_z_publisher_t *pub);
 void _z_publisher_free(_z_publisher_t **pub);
-bool _z_publisher_check(const _z_publisher_t *publisher);
-_z_publisher_t _z_publisher_null(void);
 #endif
 
 #endif /* INCLUDE_ZENOH_PICO_NET_PUBLISH_H */
diff --git a/include/zenoh-pico/net/query.h b/include/zenoh-pico/net/query.h
index 5e57c1eee..703688a65 100644
--- a/include/zenoh-pico/net/query.h
+++ b/include/zenoh-pico/net/query.h
@@ -34,7 +34,8 @@ typedef struct _z_query_t {
     bool _anyke;
 } _z_query_t;
 
-_z_query_t _z_query_null(void);
+// Warning: None of the sub-types require a non-0 initialization. Add a init function if it changes.
+static inline _z_query_t _z_query_null(void) { return (_z_query_t){0}; }
 void _z_query_clear(_z_query_t *q);
 z_result_t _z_query_copy(_z_query_t *dst, const _z_query_t *src);
 void _z_query_free(_z_query_t **query);
@@ -50,12 +51,14 @@ typedef struct {
 } _z_queryable_t;
 
 #if Z_FEATURE_QUERYABLE == 1
+// Warning: None of the sub-types require a non-0 initialization. Add a init function if it changes.
+static inline _z_queryable_t _z_queryable_null(void) { return (_z_queryable_t){0}; }
+static inline bool _z_queryable_check(const _z_queryable_t *queryable) { return !_Z_RC_IS_NULL(&queryable->_zn); }
 _z_query_t _z_query_create(_z_value_t *value, _z_keyexpr_t *key, const _z_slice_t *parameters, _z_session_rc_t *zn,
                            uint32_t request_id, const _z_bytes_t attachment);
 void _z_queryable_clear(_z_queryable_t *qbl);
 void _z_queryable_free(_z_queryable_t **qbl);
-_z_queryable_t _z_queryable_null(void);
-bool _z_queryable_check(const _z_queryable_t *queryable);
+
 #endif
 
 #endif /* ZENOH_PICO_QUERY_NETAPI_H */
diff --git a/include/zenoh-pico/net/reply.h b/include/zenoh-pico/net/reply.h
index 14ef1b232..c68fcf678 100644
--- a/include/zenoh-pico/net/reply.h
+++ b/include/zenoh-pico/net/reply.h
@@ -57,6 +57,13 @@ typedef struct _z_reply_data_t {
     _z_reply_tag_t _tag;
 } _z_reply_data_t;
 
+// Warning: None of the sub-types require a non-0 initialization. Add a init function if it changes.
+static inline _z_reply_data_t _z_reply_data_null(void) { return (_z_reply_data_t){0}; }
+static inline _z_reply_data_t _z_reply_data_init(void) {
+    _z_reply_data_t reply_data = _z_reply_data_null();
+    reply_data._tag = _Z_REPLY_TAG_NONE;
+    return reply_data;
+}
 void _z_reply_data_clear(_z_reply_data_t *rd);
 z_result_t _z_reply_data_copy(_z_reply_data_t *dst, const _z_reply_data_t *src);
 
@@ -76,9 +83,9 @@ typedef struct _z_reply_t {
     _z_reply_data_t data;
 } _z_reply_t;
 
+// Warning: None of the sub-types require a non-0 initialization. Add a init function if it changes.
+static inline _z_reply_t _z_reply_null(void) { return (_z_reply_t){0}; }
 _z_reply_t _z_reply_move(_z_reply_t *src_reply);
-
-_z_reply_t _z_reply_null(void);
 void _z_reply_clear(_z_reply_t *src);
 void _z_reply_free(_z_reply_t **hello);
 z_result_t _z_reply_copy(_z_reply_t *dst, const _z_reply_t *src);
diff --git a/include/zenoh-pico/net/sample.h b/include/zenoh-pico/net/sample.h
index 9fadfbc76..213e1eaa1 100644
--- a/include/zenoh-pico/net/sample.h
+++ b/include/zenoh-pico/net/sample.h
@@ -40,8 +40,12 @@ typedef struct _z_sample_t {
 } _z_sample_t;
 void _z_sample_clear(_z_sample_t *sample);
 
-_z_sample_t _z_sample_null(void);
-bool _z_sample_check(const _z_sample_t *sample);
+// Warning: None of the sub-types require a non-0 initialization. Add a init function if it changes.
+static inline _z_sample_t _z_sample_null(void) { return (_z_sample_t){0}; }
+static inline bool _z_sample_check(const _z_sample_t *sample) {
+    return _z_keyexpr_check(&sample->keyexpr) || _z_encoding_check(&sample->encoding) ||
+           _z_bytes_check(&sample->payload) || _z_bytes_check(&sample->attachment);
+}
 void _z_sample_move(_z_sample_t *dst, _z_sample_t *src);
 
 /**
diff --git a/include/zenoh-pico/net/subscribe.h b/include/zenoh-pico/net/subscribe.h
index 4cf0cb4d4..b8129673e 100644
--- a/include/zenoh-pico/net/subscribe.h
+++ b/include/zenoh-pico/net/subscribe.h
@@ -29,11 +29,12 @@ typedef struct {
 } _z_subscriber_t;
 
 #if Z_FEATURE_SUBSCRIPTION == 1
-
+// Warning: None of the sub-types require a non-0 initialization. Add a init function if it changes.
+static inline _z_subscriber_t _z_subscriber_null(void) { return (_z_subscriber_t){0}; }
+static inline bool _z_subscriber_check(const _z_subscriber_t *subscriber) { return !_Z_RC_IS_NULL(&subscriber->_zn); }
 void _z_subscriber_clear(_z_subscriber_t *sub);
 void _z_subscriber_free(_z_subscriber_t **sub);
-bool _z_subscriber_check(const _z_subscriber_t *subscriber);
-_z_subscriber_t _z_subscriber_null(void);
+
 #endif
 
 #endif /* ZENOH_PICO_SUBSCRIBE_NETAPI_H */
diff --git a/include/zenoh-pico/protocol/core.h b/include/zenoh-pico/protocol/core.h
index 7dcf49508..d5f85299a 100644
--- a/include/zenoh-pico/protocol/core.h
+++ b/include/zenoh-pico/protocol/core.h
@@ -66,8 +66,9 @@ typedef struct {
     uint64_t time;
 } _z_timestamp_t;
 
+// Warning: None of the sub-types require a non-0 initialization. Add a init function if it changes.
+static inline _z_timestamp_t _z_timestamp_null(void) { return (_z_timestamp_t){0}; }
 _z_timestamp_t _z_timestamp_duplicate(const _z_timestamp_t *tstamp);
-_z_timestamp_t _z_timestamp_null(void);
 void _z_timestamp_clear(_z_timestamp_t *tstamp);
 bool _z_timestamp_check(const _z_timestamp_t *stamp);
 uint64_t _z_timestamp_ntp64_from_time(uint32_t seconds, uint32_t nanos);
@@ -163,7 +164,9 @@ typedef struct {
     _z_bytes_t payload;
     _z_encoding_t encoding;
 } _z_value_t;
-_z_value_t _z_value_null(void);
+
+// Warning: None of the sub-types require a non-0 initialization. Add a init function if it changes.
+static inline _z_value_t _z_value_null(void) { return (_z_value_t){0}; }
 _z_value_t _z_value_steal(_z_value_t *value);
 z_result_t _z_value_copy(_z_value_t *dst, const _z_value_t *src);
 void _z_value_move(_z_value_t *dst, _z_value_t *src);
@@ -184,10 +187,13 @@ typedef struct {
     z_whatami_t _whatami;
     uint8_t _version;
 } _z_hello_t;
+
+// Warning: None of the sub-types require a non-0 initialization. Add a init function if it changes.
+static inline _z_hello_t _z_hello_null(void) { return (_z_hello_t){0}; }
 void _z_hello_clear(_z_hello_t *src);
 void _z_hello_free(_z_hello_t **hello);
 z_result_t _z_hello_copy(_z_hello_t *dst, const _z_hello_t *src);
-_z_hello_t _z_hello_null(void);
+
 bool _z_hello_check(const _z_hello_t *hello);
 
 _Z_ELEM_DEFINE(_z_hello, _z_hello_t, _z_noop_size, _z_hello_clear, _z_noop_copy)
@@ -202,7 +208,9 @@ typedef struct {
     uint32_t _entity_id;
     uint32_t _source_sn;
 } _z_source_info_t;
-_z_source_info_t _z_source_info_null(void);
+
+// Warning: None of the sub-types require a non-0 initialization. Add a init function if it changes.
+static inline _z_source_info_t _z_source_info_null(void) { return (_z_source_info_t){0}; }
 
 typedef struct {
     uint32_t _request_id;
diff --git a/include/zenoh-pico/protocol/definitions/declarations.h b/include/zenoh-pico/protocol/definitions/declarations.h
index c33cab627..cb8224239 100644
--- a/include/zenoh-pico/protocol/definitions/declarations.h
+++ b/include/zenoh-pico/protocol/definitions/declarations.h
@@ -24,22 +24,26 @@ typedef struct {
     uint16_t _id;
     _z_keyexpr_t _keyexpr;
 } _z_decl_kexpr_t;
-_z_decl_kexpr_t _z_decl_kexpr_null(void);
+// Warning: None of the sub-types require a non-0 initialization. Add a init function if it changes.
+static inline _z_decl_kexpr_t _z_decl_kexpr_null(void) { return (_z_decl_kexpr_t){0}; }
 typedef struct {
     uint16_t _id;
 } _z_undecl_kexpr_t;
-_z_undecl_kexpr_t _z_undecl_kexpr_null(void);
+// Warning: None of the sub-types require a non-0 initialization. Add a init function if it changes.
+static inline _z_undecl_kexpr_t _z_undecl_kexpr_null(void) { return (_z_undecl_kexpr_t){0}; }
 
 typedef struct {
     _z_keyexpr_t _keyexpr;
     uint32_t _id;
 } _z_decl_subscriber_t;
-_z_decl_subscriber_t _z_decl_subscriber_null(void);
+// Warning: None of the sub-types require a non-0 initialization. Add a init function if it changes.
+static inline _z_decl_subscriber_t _z_decl_subscriber_null(void) { return (_z_decl_subscriber_t){0}; }
 typedef struct {
     uint32_t _id;
     _z_keyexpr_t _ext_keyexpr;
 } _z_undecl_subscriber_t;
-_z_undecl_subscriber_t _z_undecl_subscriber_null(void);
+// Warning: None of the sub-types require a non-0 initialization. Add a init function if it changes.
+static inline _z_undecl_subscriber_t _z_undecl_subscriber_null(void) { return (_z_undecl_subscriber_t){0}; }
 
 typedef struct {
     _z_keyexpr_t _keyexpr;
@@ -49,28 +53,33 @@ typedef struct {
         uint16_t _distance;
     } _ext_queryable_info;
 } _z_decl_queryable_t;
-_z_decl_queryable_t _z_decl_queryable_null(void);
+// Warning: None of the sub-types require a non-0 initialization. Add a init function if it changes.
+static inline _z_decl_queryable_t _z_decl_queryable_null(void) { return (_z_decl_queryable_t){0}; }
 typedef struct {
     uint32_t _id;
     _z_keyexpr_t _ext_keyexpr;
 } _z_undecl_queryable_t;
-_z_undecl_queryable_t _z_undecl_queryable_null(void);
+// Warning: None of the sub-types require a non-0 initialization. Add a init function if it changes.
+static inline _z_undecl_queryable_t _z_undecl_queryable_null(void) { return (_z_undecl_queryable_t){0}; }
 
 typedef struct {
     _z_keyexpr_t _keyexpr;
     uint32_t _id;
 } _z_decl_token_t;
-_z_decl_token_t _z_decl_token_null(void);
+// Warning: None of the sub-types require a non-0 initialization. Add a init function if it changes.
+static inline _z_decl_token_t _z_decl_token_null(void) { return (_z_decl_token_t){0}; }
 typedef struct {
     uint32_t _id;
     _z_keyexpr_t _ext_keyexpr;
 } _z_undecl_token_t;
-_z_undecl_token_t _z_undecl_token_null(void);
+// Warning: None of the sub-types require a non-0 initialization. Add a init function if it changes.
+static inline _z_undecl_token_t _z_undecl_token_null(void) { return (_z_undecl_token_t){0}; }
 
 typedef struct {
     bool _placeholder;  // In case we add extensions
 } _z_decl_final_t;
-_z_decl_final_t _z_decl_final_null(void);
+// Warning: None of the sub-types require a non-0 initialization. Add a init function if it changes.
+static inline _z_decl_final_t _z_decl_final_null(void) { return (_z_decl_final_t){0}; }
 
 typedef struct {
     enum {
diff --git a/include/zenoh-pico/protocol/definitions/interest.h b/include/zenoh-pico/protocol/definitions/interest.h
index ca2900874..8479f090f 100644
--- a/include/zenoh-pico/protocol/definitions/interest.h
+++ b/include/zenoh-pico/protocol/definitions/interest.h
@@ -36,10 +36,10 @@ typedef struct {
     uint32_t _id;
     uint8_t flags;
 } _z_interest_t;
-_z_interest_t _z_interest_null(void);
 
+// Warning: None of the sub-types require a non-0 initialization. Add a init function if it changes.
+static inline _z_interest_t _z_interest_null(void) { return (_z_interest_t){0}; }
 void _z_interest_clear(_z_interest_t* decl);
-
 _z_interest_t _z_make_interest(_Z_MOVE(_z_keyexpr_t) key, uint32_t id, uint8_t flags);
 _z_interest_t _z_make_interest_final(uint32_t id);
 
diff --git a/include/zenoh-pico/protocol/definitions/network.h b/include/zenoh-pico/protocol/definitions/network.h
index f0cd40f01..476831765 100644
--- a/include/zenoh-pico/protocol/definitions/network.h
+++ b/include/zenoh-pico/protocol/definitions/network.h
@@ -149,7 +149,9 @@ _z_n_msg_request_exts_t _z_n_msg_request_needed_exts(const _z_n_msg_request_t *m
 void _z_n_msg_request_clear(_z_n_msg_request_t *msg);
 
 typedef _z_reply_body_t _z_push_body_t;
-_z_push_body_t _z_push_body_null(void);
+// Warning: None of the sub-types require a non-0 initialization. Add a init function if it changes.
+static inline _z_push_body_t _z_push_body_null(void) { return (_z_push_body_t){0}; }
+
 _z_push_body_t _z_push_body_steal(_z_push_body_t *msg);
 void _z_push_body_clear(_z_push_body_t *msg);
 
diff --git a/include/zenoh-pico/protocol/keyexpr.h b/include/zenoh-pico/protocol/keyexpr.h
index f171ee32f..61a16e634 100644
--- a/include/zenoh-pico/protocol/keyexpr.h
+++ b/include/zenoh-pico/protocol/keyexpr.h
@@ -26,20 +26,25 @@ bool _z_keyexpr_suffix_intersects(const _z_keyexpr_t *left, const _z_keyexpr_t *
 bool _z_keyexpr_suffix_equals(const _z_keyexpr_t *left, const _z_keyexpr_t *right);
 
 /*------------------ clone/Copy/Free helpers ------------------*/
+// Warning: None of the sub-types require a non-0 initialization. Add a init function if it changes.
+static inline _z_keyexpr_t _z_keyexpr_null(void) { return (_z_keyexpr_t){0}; }
+static inline _z_keyexpr_t _z_keyexpr_alias(const _z_keyexpr_t src) {
+    return (_z_keyexpr_t){
+        ._id = src._id,
+        ._mapping = src._mapping,
+        ._suffix = _z_string_alias(src._suffix),
+    };
+}
+
 _z_keyexpr_t _z_keyexpr_from_string(uint16_t rid, _z_string_t *str);
 _z_keyexpr_t _z_keyexpr_from_substr(uint16_t rid, const char *str, size_t len);
 z_result_t _z_keyexpr_copy(_z_keyexpr_t *dst, const _z_keyexpr_t *src);
-_z_keyexpr_t _z_keyexpr_duplicate(_z_keyexpr_t src);
-_z_keyexpr_t _z_keyexpr_alias(_z_keyexpr_t src);
+_z_keyexpr_t _z_keyexpr_duplicate(const _z_keyexpr_t *src);
 /// Returns either keyexpr defined by id + mapping with null suffix if try_declared is true and id is non-zero,
 /// or keyexpr defined by its suffix only, with 0 id and no mapping. This is to be used only when forwarding
 /// keyexpr in user api to properly separate declared keyexpr from its suffix.
 _z_keyexpr_t _z_keyexpr_alias_from_user_defined(_z_keyexpr_t src, bool try_declared);
 _z_keyexpr_t _z_keyexpr_steal(_Z_MOVE(_z_keyexpr_t) src);
-static inline _z_keyexpr_t _z_keyexpr_null(void) {
-    _z_keyexpr_t keyexpr = {0, {0}, _z_string_null()};
-    return keyexpr;
-}
 bool _z_keyexpr_equals(const _z_keyexpr_t *left, const _z_keyexpr_t *right);
 void _z_keyexpr_move(_z_keyexpr_t *dst, _z_keyexpr_t *src);
 void _z_keyexpr_clear(_z_keyexpr_t *rk);
diff --git a/src/api/api.c b/src/api/api.c
index d5404d691..81f71d543 100644
--- a/src/api/api.c
+++ b/src/api/api.c
@@ -64,7 +64,7 @@ _z_string_svec_t _z_string_array_null(void) { return _z_string_svec_make(0); }
 void z_string_array_new(z_owned_string_array_t *a) { a->_val = _z_string_array_null(); }
 
 size_t z_string_array_push_by_alias(z_loaned_string_array_t *a, const z_loaned_string_t *value) {
-    _z_string_t str = _z_string_alias(value);
+    _z_string_t str = _z_string_alias(*value);
     _z_string_svec_append(a, &str);
 
     return _z_string_svec_len(a);
@@ -130,7 +130,7 @@ void z_view_keyexpr_from_substr_unchecked(z_view_keyexpr_t *keyexpr, const char
 }
 
 z_result_t z_keyexpr_as_view_string(const z_loaned_keyexpr_t *keyexpr, z_view_string_t *s) {
-    s->_val = _z_string_alias(&keyexpr->_suffix);
+    s->_val = _z_string_alias(keyexpr->_suffix);
     return _Z_RES_OK;
 }
 
@@ -829,11 +829,13 @@ z_result_t z_put(const z_loaned_session_t *zs, const z_loaned_keyexpr_t *keyexpr
                    reliability);
 
     // Trigger local subscriptions
+#if Z_FEATURE_LOCAL_SUBSCRIBER == 1
     _z_trigger_local_subscriptions(
         _Z_RC_IN_VAL(zs), keyexpr_aliased, _z_bytes_from_owned_bytes(&payload->_this),
         opt.encoding == NULL ? NULL : &opt.encoding->_this._val,
         _z_n_qos_make(opt.is_express, opt.congestion_control == Z_CONGESTION_CONTROL_BLOCK, opt.priority),
         opt.timestamp, _z_bytes_from_owned_bytes(&opt.attachment->_this), reliability);
+#endif
     // Clean-up
     z_encoding_drop(opt.encoding);
     z_bytes_drop(opt.attachment);
@@ -962,10 +964,12 @@ z_result_t z_publisher_put(const z_loaned_publisher_t *pub, z_moved_bytes_t *pay
                            _z_bytes_from_owned_bytes(&opt.attachment->_this), reliability);
         }
         // Trigger local subscriptions
+#if Z_FEATURE_LOCAL_SUBSCRIBER == 1
         _z_trigger_local_subscriptions(
             _Z_RC_IN_VAL(&sess_rc), pub_keyexpr, _z_bytes_from_owned_bytes(&payload->_this), &encoding,
             _z_n_qos_make(pub->_is_express, pub->_congestion_control == Z_CONGESTION_CONTROL_BLOCK, pub->_priority),
             opt.timestamp, _z_bytes_from_owned_bytes(&opt.attachment->_this), reliability);
+#endif
 
         _z_session_rc_drop(&sess_rc);
     } else {
diff --git a/src/collections/bytes.c b/src/collections/bytes.c
index 698e4bb5a..e4328cd40 100644
--- a/src/collections/bytes.c
+++ b/src/collections/bytes.c
@@ -27,12 +27,6 @@
 /*-------- Bytes --------*/
 bool _z_bytes_check(const _z_bytes_t *bytes) { return !_z_bytes_is_empty(bytes); }
 
-_z_bytes_t _z_bytes_null(void) {
-    _z_bytes_t b;
-    b._slices = _z_arc_slice_svec_make(0);
-    return b;
-}
-
 z_result_t _z_bytes_copy(_z_bytes_t *dst, const _z_bytes_t *src) {
     _z_arc_slice_svec_copy(&dst->_slices, &src->_slices);
     if (_z_arc_slice_svec_len(&dst->_slices) == _z_arc_slice_svec_len(&src->_slices)) {
diff --git a/src/collections/slice.c b/src/collections/slice.c
index c6fe1171a..76ffcf96e 100644
--- a/src/collections/slice.c
+++ b/src/collections/slice.c
@@ -28,14 +28,8 @@ void _z_default_deleter(void *data, void *context) {
     z_free(data);
 }
 
-_z_delete_context_t _z_delete_context_null(void) { return _z_delete_context_create(NULL, NULL); }
-
 bool _z_delete_context_is_null(const _z_delete_context_t *c) { return c->deleter == NULL; }
 
-_z_delete_context_t _z_delete_context_create(void (*deleter)(void *data, void *context), void *context) {
-    return (_z_delete_context_t){.deleter = deleter, .context = context};
-}
-
 _z_delete_context_t _z_delete_context_default(void) { return _z_delete_context_create(_z_default_deleter, NULL); }
 
 void _z_delete_context_delete(_z_delete_context_t *c, void *data) {
@@ -45,27 +39,16 @@ void _z_delete_context_delete(_z_delete_context_t *c, void *data) {
 }
 
 /*-------- Slice --------*/
-_z_slice_t _z_slice_empty(void) {
-    return (_z_slice_t){.start = NULL, .len = 0, ._delete_context = _z_delete_context_null()};
-}
-
 z_result_t _z_slice_init(_z_slice_t *bs, size_t capacity) {
-    z_result_t ret = _Z_RES_OK;
-
-    bs->start = capacity == 0 ? NULL : (uint8_t *)z_malloc(capacity);
-    if (bs->start != NULL) {
-        bs->len = capacity;
-        bs->_delete_context = _z_delete_context_default();
-    } else {
+    bs->start = (uint8_t *)z_malloc(capacity);
+    if (bs->start == NULL) {
         bs->len = 0;
         bs->_delete_context = _z_delete_context_null();
+        return _Z_ERR_SYSTEM_OUT_OF_MEMORY;
     }
-
-    if (bs->len != capacity) {
-        ret = _Z_ERR_SYSTEM_OUT_OF_MEMORY;
-    }
-
-    return ret;
+    bs->len = capacity;
+    bs->_delete_context = _z_delete_context_default();
+    return _Z_RES_OK;
 }
 
 _z_slice_t _z_slice_make(size_t capacity) {
@@ -82,11 +65,6 @@ _z_slice_t _z_slice_from_buf_custom_deleter(const uint8_t *p, size_t len, _z_del
     return bs;
 }
 
-_z_slice_t _z_slice_alias(const _z_slice_t *bs) {
-    _z_slice_t alias = {.len = bs->len, .start = bs->start, ._delete_context = _z_delete_context_null()};
-    return alias;
-}
-
 _z_slice_t _z_slice_alias_buf(const uint8_t *p, size_t len) {
     return _z_slice_from_buf_custom_deleter(p, len, _z_delete_context_null());
 }
@@ -154,8 +132,6 @@ _z_slice_t _z_slice_duplicate(const _z_slice_t *src) {
     return dst;
 }
 
-bool _z_slice_is_empty(const _z_slice_t *bs) { return bs->len == 0; }
-
 _z_slice_t _z_slice_steal(_z_slice_t *b) {
     _z_slice_t ret = *b;
     *b = _z_slice_empty();
diff --git a/src/collections/string.c b/src/collections/string.c
index 753c7cad5..a2545e767 100644
--- a/src/collections/string.c
+++ b/src/collections/string.c
@@ -17,16 +17,10 @@
 #include <stddef.h>
 #include <string.h>
 
+#include "zenoh-pico/utils/logging.h"
 #include "zenoh-pico/utils/pointers.h"
 
 /*-------- string --------*/
-_z_string_t _z_string_null(void) {
-    _z_string_t s = {._slice = _z_slice_empty()};
-    return s;
-}
-
-bool _z_string_check(const _z_string_t *value) { return !_z_slice_is_empty(&value->_slice); }
-
 _z_string_t _z_string_copy_from_str(const char *value) {
     _z_string_t s;
     s._slice = _z_slice_copy_from_buf((uint8_t *)value, strlen(value));
@@ -85,11 +79,6 @@ _z_string_t _z_string_steal(_z_string_t *str) {
     return ret;
 }
 
-_z_string_t _z_string_alias(const _z_string_t *str) {
-    _z_string_t alias = {._slice = _z_slice_alias(&str->_slice)};
-    return alias;
-}
-
 void _z_string_move_str(_z_string_t *dst, char *src) { *dst = _z_string_alias_str(src); }
 
 void _z_string_reset(_z_string_t *str) { _z_slice_reset(&str->_slice); }
@@ -131,10 +120,10 @@ _z_string_t _z_string_convert_bytes(const _z_slice_t *bs) {
 }
 
 _z_string_t _z_string_preallocate(size_t len) {
-    _z_string_t s = _z_string_null();
-    _z_slice_init(&s._slice, len);
-    if (_z_slice_is_empty(&s._slice)) {
-        return _z_string_null();
+    _z_string_t s;
+    // As long as _z_string_t is only a slice, no need to do anything more
+    if (_z_slice_init(&s._slice, len) != _Z_RES_OK) {
+        _Z_ERROR("String allocation failed");
     }
     return s;
 }
diff --git a/src/net/encoding.c b/src/net/encoding.c
index 5926f4657..f2fccb861 100644
--- a/src/net/encoding.c
+++ b/src/net/encoding.c
@@ -19,6 +19,11 @@
 #include "zenoh-pico/utils/logging.h"
 #include "zenoh-pico/utils/result.h"
 
+_z_encoding_t _z_encoding_wrap(uint16_t id, const char *schema) {
+    return (_z_encoding_t){.id = id,
+                           .schema = (schema == NULL) ? _z_string_null() : _z_string_alias_str((char *)schema)};
+}
+
 z_result_t _z_encoding_make(_z_encoding_t *encoding, uint16_t id, const char *schema, size_t len) {
     encoding->id = id;
     // Clone schema
@@ -33,19 +38,8 @@ z_result_t _z_encoding_make(_z_encoding_t *encoding, uint16_t id, const char *sc
     return _Z_RES_OK;
 }
 
-_z_encoding_t _z_encoding_wrap(uint16_t id, const char *schema) {
-    return (_z_encoding_t){.id = id,
-                           .schema = (schema == NULL) ? _z_string_null() : _z_string_alias_str((char *)schema)};
-}
-
-_z_encoding_t _z_encoding_null(void) { return _z_encoding_wrap(_Z_ENCODING_ID_DEFAULT, NULL); }
-
 void _z_encoding_clear(_z_encoding_t *encoding) { _z_string_clear(&encoding->schema); }
 
-bool _z_encoding_check(const _z_encoding_t *encoding) {
-    return ((encoding->id != _Z_ENCODING_ID_DEFAULT) || _z_string_check(&encoding->schema));
-}
-
 z_result_t _z_encoding_copy(_z_encoding_t *dst, const _z_encoding_t *src) {
     *dst = _z_encoding_null();
     _Z_RETURN_IF_ERR(_z_string_copy(&dst->schema, &src->schema));
diff --git a/src/net/primitives.c b/src/net/primitives.c
index b2b8d9d7d..96c0b919f 100644
--- a/src/net/primitives.c
+++ b/src/net/primitives.c
@@ -108,7 +108,7 @@ _z_publisher_t _z_declare_publisher(const _z_session_rc_t *zn, _z_keyexpr_t keye
     // Allocate publisher
     _z_publisher_t ret;
     // Fill publisher
-    ret._key = _z_keyexpr_duplicate(keyexpr);
+    ret._key = _z_keyexpr_duplicate(&keyexpr);
     ret._id = _z_get_entity_id(_Z_RC_IN_VAL(zn));
     ret._congestion_control = congestion_control;
     ret._priority = priority;
diff --git a/src/net/publish.c b/src/net/publish.c
index d81893d0b..13900de39 100644
--- a/src/net/publish.c
+++ b/src/net/publish.c
@@ -35,17 +35,4 @@ void _z_publisher_free(_z_publisher_t **pub) {
     }
 }
 
-bool _z_publisher_check(const _z_publisher_t *publisher) { return !_Z_RC_IS_NULL(&publisher->_zn); }
-_z_publisher_t _z_publisher_null(void) {
-    return (_z_publisher_t){._congestion_control = Z_CONGESTION_CONTROL_DEFAULT,
-                            ._id = 0,
-                            ._key = _z_keyexpr_null(),
-                            ._priority = Z_PRIORITY_DEFAULT,
-                            ._zn = _z_session_weak_null(),
-                            ._encoding = _z_encoding_null(),
-#if Z_FEATURE_INTEREST == 1
-                            ._filter = (_z_write_filter_t){._interest_id = 0, .ctx = NULL}
-#endif
-    };
-}
 #endif
diff --git a/src/net/query.c b/src/net/query.c
index 75bde3f41..9230c1dde 100644
--- a/src/net/query.c
+++ b/src/net/query.c
@@ -16,18 +16,6 @@
 #include "zenoh-pico/session/utils.h"
 #include "zenoh-pico/utils/logging.h"
 
-_z_query_t _z_query_null(void) {
-    return (_z_query_t){
-        ._anyke = false,
-        ._key = _z_keyexpr_null(),
-        ._parameters = NULL,
-        ._request_id = 0,
-        ._value = _z_value_null(),
-        .attachment = _z_bytes_null(),
-        ._zn = _z_session_weak_null(),
-    };
-}
-
 void _z_query_clear_inner(_z_query_t *q) {
     _z_keyexpr_clear(&q->_key);
     _z_value_clear(&q->_value);
@@ -99,10 +87,6 @@ _z_query_t _z_query_create(_z_value_t *value, _z_keyexpr_t *key, const _z_slice_
     return q;
 }
 
-_z_queryable_t _z_queryable_null(void) { return (_z_queryable_t){._entity_id = 0, ._zn = _z_session_weak_null()}; }
-
-bool _z_queryable_check(const _z_queryable_t *queryable) { return !_Z_RC_IS_NULL(&queryable->_zn); }
-
 void _z_queryable_clear(_z_queryable_t *qbl) {
     _z_session_weak_drop(&qbl->_zn);
     *qbl = _z_queryable_null();
diff --git a/src/net/reply.c b/src/net/reply.c
index b9038af2e..a331ae6cf 100644
--- a/src/net/reply.c
+++ b/src/net/reply.c
@@ -17,15 +17,6 @@
 #include "zenoh-pico/session/utils.h"
 #include "zenoh-pico/utils/logging.h"
 
-_z_reply_data_t _z_reply_data_null(void) {
-    return (_z_reply_data_t){.replier_id = {.id = {0}}, ._result.sample = _z_sample_null(), ._tag = _Z_REPLY_TAG_NONE};
-}
-
-_z_reply_t _z_reply_null(void) {
-    _z_reply_t r = {.data = _z_reply_data_null()};
-    return r;
-}
-
 #if Z_FEATURE_QUERY == 1
 void _z_reply_data_clear(_z_reply_data_t *reply_data) {
     if (reply_data->_tag == _Z_REPLY_TAG_DATA) {
@@ -48,14 +39,14 @@ void _z_reply_data_free(_z_reply_data_t **reply_data) {
 }
 
 z_result_t _z_reply_data_copy(_z_reply_data_t *dst, const _z_reply_data_t *src) {
-    *dst = _z_reply_data_null();
+    *dst = _z_reply_data_init();
     if (src->_tag == _Z_REPLY_TAG_DATA) {
         _Z_RETURN_IF_ERR(_z_sample_copy(&dst->_result.sample, &src->_result.sample));
     } else if (src->_tag == _Z_REPLY_TAG_ERROR) {
         _Z_RETURN_IF_ERR(_z_value_copy(&dst->_result.error, &src->_result.error));
     }
-    dst->replier_id = src->replier_id;
     dst->_tag = src->_tag;
+    dst->replier_id = src->replier_id;
     return _Z_RES_OK;
 }
 
diff --git a/src/net/sample.c b/src/net/sample.c
index 6248f57e5..042fbcd83 100644
--- a/src/net/sample.c
+++ b/src/net/sample.c
@@ -16,24 +16,6 @@
 #include "zenoh-pico/session/utils.h"
 #include "zenoh-pico/utils/logging.h"
 
-_z_sample_t _z_sample_null(void) {
-    _z_sample_t s = {
-        .keyexpr = _z_keyexpr_null(),
-        .payload = _z_bytes_null(),
-        .encoding = _z_encoding_null(),
-        .timestamp = _z_timestamp_null(),
-        .kind = 0,
-        .qos = {0},
-        .attachment = _z_bytes_null(),
-    };
-    return s;
-}
-
-bool _z_sample_check(const _z_sample_t *sample) {
-    return _z_keyexpr_check(&sample->keyexpr) || _z_bytes_check(&sample->payload) ||
-           _z_bytes_check(&sample->attachment) || _z_encoding_check(&sample->encoding);
-}
-
 void _z_sample_move(_z_sample_t *dst, _z_sample_t *src) {
     _z_keyexpr_move(&dst->keyexpr, &src->keyexpr);
     _z_bytes_move(&dst->payload, &src->payload);
diff --git a/src/net/subscribe.c b/src/net/subscribe.c
index 84960a0a2..12a83c6ac 100644
--- a/src/net/subscribe.c
+++ b/src/net/subscribe.c
@@ -31,7 +31,4 @@ void _z_subscriber_free(_z_subscriber_t **sub) {
     }
 }
 
-bool _z_subscriber_check(const _z_subscriber_t *subscriber) { return !_Z_RC_IS_NULL(&subscriber->_zn); }
-_z_subscriber_t _z_subscriber_null(void) { return (_z_subscriber_t){._entity_id = 0, ._zn = _z_session_weak_null()}; }
-
 #endif
diff --git a/src/protocol/core.c b/src/protocol/core.c
index ed0479cc5..de0dbf517 100644
--- a/src/protocol/core.c
+++ b/src/protocol/core.c
@@ -66,11 +66,6 @@ _z_id_t _z_id_empty(void) {
                      }};
 }
 
-_z_source_info_t _z_source_info_null(void) {
-    return (_z_source_info_t){._source_sn = 0, ._entity_id = 0, ._id = _z_id_empty()};
-}
-_z_timestamp_t _z_timestamp_null(void) { return (_z_timestamp_t){.id = _z_id_empty(), .time = 0}; }
-
 uint64_t _z_timestamp_ntp64_from_time(uint32_t seconds, uint32_t nanos) {
     const uint64_t FRAC_PER_SEC = (uint64_t)1 << 32;
     const uint64_t NANOS_PER_SEC = 1000000000;
@@ -79,7 +74,6 @@ uint64_t _z_timestamp_ntp64_from_time(uint32_t seconds, uint32_t nanos) {
     return ((uint64_t)seconds << 32) | fractions;
 }
 
-_z_value_t _z_value_null(void) { return (_z_value_t){.payload = _z_bytes_null(), .encoding = _z_encoding_null()}; }
 _z_value_t _z_value_steal(_z_value_t *value) {
     _z_value_t ret = *value;
     *value = _z_value_null();
@@ -101,10 +95,6 @@ z_result_t _z_hello_copy(_z_hello_t *dst, const _z_hello_t *src) {
     return _Z_RES_OK;
 }
 
-_z_hello_t _z_hello_null(void) {
-    return (_z_hello_t){._zid = _z_id_empty(), ._version = 0, ._whatami = 0x0, ._locators = _z_string_svec_make(0)};
-}
-
 void _z_value_move(_z_value_t *dst, _z_value_t *src) {
     _z_encoding_move(&dst->encoding, &src->encoding);
     _z_bytes_move(&dst->payload, &src->payload);
diff --git a/src/protocol/definitions/declarations.c b/src/protocol/definitions/declarations.c
index 878f14f6d..df693f2a1 100644
--- a/src/protocol/definitions/declarations.c
+++ b/src/protocol/definitions/declarations.c
@@ -71,7 +71,7 @@ _z_declaration_t _z_make_undecl_subscriber(uint32_t id, _Z_OPTIONAL const _z_key
     return (_z_declaration_t){
         ._tag = _Z_UNDECL_SUBSCRIBER,
         ._body = {._undecl_subscriber = {
-                      ._id = id, ._ext_keyexpr = (key == NULL) ? _z_keyexpr_null() : _z_keyexpr_duplicate(*key)}}};
+                      ._id = id, ._ext_keyexpr = (key == NULL) ? _z_keyexpr_null() : _z_keyexpr_duplicate(key)}}};
 }
 
 _z_declaration_t _z_make_decl_queryable(_Z_MOVE(_z_keyexpr_t) key, uint32_t id, bool complete, uint16_t distance) {
@@ -85,7 +85,7 @@ _z_declaration_t _z_make_undecl_queryable(uint32_t id, _Z_OPTIONAL const _z_keye
     return (_z_declaration_t){
         ._tag = _Z_UNDECL_QUERYABLE,
         ._body = {._undecl_queryable = {
-                      ._id = id, ._ext_keyexpr = (key == NULL) ? _z_keyexpr_null() : _z_keyexpr_duplicate(*key)}}};
+                      ._id = id, ._ext_keyexpr = (key == NULL) ? _z_keyexpr_null() : _z_keyexpr_duplicate(key)}}};
 }
 _z_declaration_t _z_make_decl_token(_Z_MOVE(_z_keyexpr_t) key, uint32_t id) {
     return (_z_declaration_t){._tag = _Z_DECL_TOKEN,
@@ -98,22 +98,12 @@ _z_declaration_t _z_make_undecl_token(uint32_t id, _Z_OPTIONAL const _z_keyexpr_
     return (_z_declaration_t){
         ._tag = _Z_UNDECL_TOKEN,
         ._body = {._undecl_token = {._id = id,
-                                    ._ext_keyexpr = (key == NULL) ? _z_keyexpr_null() : _z_keyexpr_duplicate(*key)}}};
+                                    ._ext_keyexpr = (key == NULL) ? _z_keyexpr_null() : _z_keyexpr_duplicate(key)}}};
 }
 _z_declaration_t _z_make_decl_final(void) {
     return (_z_declaration_t){._tag = _Z_DECL_FINAL, ._body = {._decl_final = {0}}};
 }
 
-_z_decl_kexpr_t _z_decl_kexpr_null(void) { return (_z_decl_kexpr_t){0}; }
-_z_decl_subscriber_t _z_decl_subscriber_null(void) { return (_z_decl_subscriber_t){0}; }
-_z_decl_queryable_t _z_decl_queryable_null(void) { return (_z_decl_queryable_t){0}; }
-_z_decl_token_t _z_decl_token_null(void) { return (_z_decl_token_t){0}; }
-_z_undecl_kexpr_t _z_undecl_kexpr_null(void) { return (_z_undecl_kexpr_t){0}; }
-_z_undecl_subscriber_t _z_undecl_subscriber_null(void) { return (_z_undecl_subscriber_t){0}; }
-_z_undecl_queryable_t _z_undecl_queryable_null(void) { return (_z_undecl_queryable_t){0}; }
-_z_undecl_token_t _z_undecl_token_null(void) { return (_z_undecl_token_t){0}; }
-_z_decl_final_t _z_decl_final_null(void) { return (_z_decl_final_t){0}; }
-
 void _z_decl_fix_mapping(_z_declaration_t *msg, uint16_t mapping) {
     switch (msg->_tag) {
         case _Z_DECL_KEXPR: {
diff --git a/src/protocol/definitions/interest.c b/src/protocol/definitions/interest.c
index 7c0254ee7..cfdc1795e 100644
--- a/src/protocol/definitions/interest.c
+++ b/src/protocol/definitions/interest.c
@@ -33,5 +33,3 @@ _z_interest_t _z_make_interest_final(uint32_t id) {
         .flags = 0,
     };
 }
-
-_z_interest_t _z_interest_null(void) { return (_z_interest_t){0}; }
diff --git a/src/protocol/definitions/network.c b/src/protocol/definitions/network.c
index 177e0bc0a..10cb27cde 100644
--- a/src/protocol/definitions/network.c
+++ b/src/protocol/definitions/network.c
@@ -72,11 +72,6 @@ _z_push_body_t _z_push_body_steal(_z_push_body_t *msg) {
     *msg = _z_push_body_null();
     return ret;
 }
-_z_push_body_t _z_push_body_null(void) {
-    return (_z_push_body_t){
-        ._is_put = false,
-        ._body._del._commons = {._timestamp = _z_timestamp_null(), ._source_info = _z_source_info_null()}};
-}
 
 void _z_n_msg_response_final_clear(_z_n_msg_response_final_t *msg) { (void)(msg); }
 
diff --git a/src/protocol/keyexpr.c b/src/protocol/keyexpr.c
index a097b2c40..f71e38875 100644
--- a/src/protocol/keyexpr.c
+++ b/src/protocol/keyexpr.c
@@ -36,7 +36,7 @@ _z_keyexpr_t _z_keyexpr_from_string(uint16_t rid, _z_string_t *str) {
     return (_z_keyexpr_t){
         ._id = rid,
         ._mapping = _z_keyexpr_mapping(_Z_KEYEXPR_MAPPING_LOCAL),
-        ._suffix = (_z_string_check(str)) ? _z_string_alias(str) : _z_string_null(),
+        ._suffix = (_z_string_check(str)) ? _z_string_alias(*str) : _z_string_null(),
     };
 }
 
@@ -59,9 +59,9 @@ z_result_t _z_keyexpr_copy(_z_keyexpr_t *dst, const _z_keyexpr_t *src) {
     return _Z_RES_OK;
 }
 
-_z_keyexpr_t _z_keyexpr_duplicate(_z_keyexpr_t src) {
+_z_keyexpr_t _z_keyexpr_duplicate(const _z_keyexpr_t *src) {
     _z_keyexpr_t dst;
-    _z_keyexpr_copy(&dst, &src);
+    _z_keyexpr_copy(&dst, src);
     return dst;
 }
 
@@ -106,15 +106,6 @@ bool _z_keyexpr_equals(const _z_keyexpr_t *left, const _z_keyexpr_t *right) {
     return _z_string_equals(&left->_suffix, &right->_suffix);
 }
 
-_z_keyexpr_t _z_keyexpr_alias(_z_keyexpr_t src) {
-    _z_keyexpr_t alias = {
-        ._id = src._id,
-        ._mapping = src._mapping,
-        ._suffix = _z_string_alias(&src._suffix),
-    };
-    return alias;
-}
-
 _z_keyexpr_t _z_keyexpr_alias_from_user_defined(_z_keyexpr_t src, bool try_declared) {
     if ((try_declared && src._id != Z_RESOURCE_ID_NONE) || !_z_keyexpr_has_suffix(&src)) {
         return (_z_keyexpr_t){
diff --git a/src/session/interest.c b/src/session/interest.c
index a16884ee7..1467cf874 100644
--- a/src/session/interest.c
+++ b/src/session/interest.c
@@ -228,7 +228,7 @@ static _z_keyexpr_t _unsafe_z_get_key_from_declare(_z_session_t *zn, uint32_t id
     while (xs != NULL) {
         _z_declare_data_t *decl = _z_declare_data_list_head(xs);
         if (_z_declare_data_eq(&comp, decl)) {
-            return _z_keyexpr_duplicate(decl->_key);
+            return _z_keyexpr_duplicate(&decl->_key);
         }
         xs = _z_declare_data_list_tail(xs);
     }
diff --git a/src/session/query.c b/src/session/query.c
index 9515f47d3..f9546990f 100644
--- a/src/session/query.c
+++ b/src/session/query.c
@@ -148,7 +148,8 @@ z_result_t _z_trigger_query_reply_partial(_z_session_t *zn, const _z_zint_t id,
                     (void)memset(&partial_reply, 0,
                                  sizeof(_z_reply_t));  // Avoid warnings on uninitialized values on the reply
                     partial_reply.data._tag = _Z_REPLY_TAG_DATA;
-                    partial_reply.data._result.sample.keyexpr = _z_keyexpr_duplicate(reply.data._result.sample.keyexpr);
+                    partial_reply.data._result.sample.keyexpr =
+                        _z_keyexpr_duplicate(&reply.data._result.sample.keyexpr);
                     pen_rep->_reply = partial_reply;
                 } else {
                     pen_rep->_reply = reply;  // Store the whole reply in the latest mode
diff --git a/src/session/resource.c b/src/session/resource.c
index b573e600a..d90a53ca3 100644
--- a/src/session/resource.c
+++ b/src/session/resource.c
@@ -88,23 +88,28 @@ _z_resource_t *__z_get_resource_by_key(_z_resource_list_t *rl, const _z_keyexpr_
 }
 
 _z_keyexpr_t __z_get_expanded_key_from_key(_z_resource_list_t *xs, const _z_keyexpr_t *keyexpr) {
-    _z_keyexpr_t ret = {._id = Z_RESOURCE_ID_NONE, ._suffix = _z_string_null(), ._mapping = _z_keyexpr_mapping(0)};
+    _z_zint_t id = keyexpr->_id;
+
+    // Check if ke is already expanded
+    if (id == Z_RESOURCE_ID_NONE) {
+        if (!_z_keyexpr_has_suffix(keyexpr)) {
+            return _z_keyexpr_null();
+        }
+        return _z_keyexpr_duplicate(keyexpr);
+    }
 
     // Need to build the complete resource name, by recursively look at RIDs
     // Resource names are looked up from right to left
+    _z_keyexpr_t ret = _z_keyexpr_null();
     _z_string_list_t *strs = NULL;
     size_t len = 0;
 
     // Append suffix as the right-most segment
     if (_z_keyexpr_has_suffix(keyexpr)) {
         len = len + _z_string_len(&keyexpr->_suffix);
-        strs = _z_string_list_push(strs, (_z_string_t *)&keyexpr->_suffix);  // Warning: list must be release with
-                                                                             //   _z_list_free(&strs, _z_noop_free);
-                                                                             //   or will release the suffix as well
+        strs = _z_string_list_push(strs, (_z_string_t *)&keyexpr->_suffix);
     }
-
     // Recursively go through all the RIDs
-    _z_zint_t id = keyexpr->_id;
     uint16_t mapping = _z_keyexpr_mapping_id(keyexpr);
     while (id != Z_RESOURCE_ID_NONE) {
         _z_resource_t *res = __z_get_resource_by_id(xs, mapping, id);
@@ -114,9 +119,7 @@ _z_keyexpr_t __z_get_expanded_key_from_key(_z_resource_list_t *xs, const _z_keye
         }
         if (_z_keyexpr_has_suffix(&res->_key)) {
             len = len + _z_string_len(&res->_key._suffix);
-            strs = _z_string_list_push(strs, &res->_key._suffix);  // Warning: list must be release with
-                                                                   //   _z_list_free(&strs, _z_noop_free);
-                                                                   //   or will release the suffix as well
+            strs = _z_string_list_push(strs, &res->_key._suffix);
         }
         id = res->_key._id;
     }
@@ -136,6 +139,7 @@ _z_keyexpr_t __z_get_expanded_key_from_key(_z_resource_list_t *xs, const _z_keye
             }
         }
     }
+    // Warning: list must be released with _z_list_free(&strs, _z_noop_free) or will release the suffix as well
     _z_list_free(&strs, _z_noop_free);
     return ret;
 }
@@ -205,7 +209,6 @@ _z_keyexpr_t _z_get_expanded_key_from_key(_z_session_t *zn, const _z_keyexpr_t *
 /// Returns the ID of the registered keyexpr. Returns 0 if registration failed.
 uint16_t _z_register_resource(_z_session_t *zn, _z_keyexpr_t key, uint16_t id, uint16_t register_to_mapping) {
     uint16_t ret = Z_RESOURCE_ID_NONE;
-    key = _z_keyexpr_alias(key);
     uint16_t mapping = register_to_mapping;
     uint16_t parent_mapping = _z_keyexpr_mapping_id(&key);
 
@@ -226,7 +229,7 @@ uint16_t _z_register_resource(_z_session_t *zn, _z_keyexpr_t key, uint16_t id, u
             ret = Z_RESOURCE_ID_NONE;
         } else {
             res->_refcount = 1;
-            res->_key = _z_keyexpr_duplicate(key);
+            res->_key = _z_keyexpr_duplicate(&key);
             ret = id == Z_RESOURCE_ID_NONE ? _z_get_resource_id(zn) : id;
             res->_id = ret;
             // Register the resource
diff --git a/src/session/subscription.c b/src/session/subscription.c
index b7bf19f26..1e0153f76 100644
--- a/src/session/subscription.c
+++ b/src/session/subscription.c
@@ -159,14 +159,18 @@ z_result_t _z_trigger_subscriptions(_z_session_t *zn, const _z_keyexpr_t keyexpr
     _Z_DEBUG("Triggering subs for %d - %.*s", key._id, (int)_z_string_len(&key._suffix), _z_string_data(&key._suffix));
     if (_z_keyexpr_has_suffix(&key)) {
         _z_subscription_rc_list_t *subs = __unsafe_z_get_subscriptions_by_key(zn, _Z_RESOURCE_IS_LOCAL, &key);
-
         _zp_session_unlock_mutex(zn);
 
+        // Check if there is subs
+        size_t sub_nb = _z_subscription_rc_list_len(subs);
+        if (sub_nb == 0) {
+            return _Z_RES_OK;
+        }
         // Build the sample
         _z_sample_t sample = _z_sample_create(&key, payload, timestamp, encoding, kind, qos, attachment, reliability);
         // Parse subscription list
         _z_subscription_rc_list_t *xs = subs;
-        _Z_DEBUG("Triggering %ju subs", (uintmax_t)_z_subscription_rc_list_len(xs));
+        _Z_DEBUG("Triggering %ju subs", (uintmax_t)sub_nb);
         while (xs != NULL) {
             _z_subscription_rc_t *sub = _z_subscription_rc_list_head(xs);
             _Z_RC_IN_VAL(sub)->_callback(&sample, _Z_RC_IN_VAL(sub)->_arg);