feat(memory): NOTE_NO_RESPONSE_RAII opt-out for arena-only builds

Phase 1 Response RAII calls `Allocator::deallocate` on every interned string in `~Response()`. For users whose Allocator's `free` is a no-op — arena_allocator, heap_reset_allocator, custom pool — this is pure overhead: ~248 B AVR flash for dtor symbols + the `release_string_fields` helper, plus per-Response RAM for the AllocatorRef. The strings are already reclaimed wholesale by `arena.reset()` / `pool.reset()`.

Define `NOTE_NO_RESPONSE_RAII=1` to drop the cleanup entirely. Under the flag, codegen omits:

* `Response::alloc_` member and `note::AllocatorRef`.
* `~Response()` body + the custom move ctor / move-assignment.
* The SINGLETON-path `rsp_.alloc_.reset(...)` line in each generated
`execute()`.
* The non-SINGLETON `Notecard::execute(req, temp_alloc)` per-call
overload (its contract depends on per-Response allocator tracking).

Not auto-implied by NOTE_MINIMAL: a NOTE_MINIMAL user can still plug in the default heap `Allocator{}` (AVR-libc has malloc/free), where the flag would silently leak interned response strings.

Tests on the `with-RAII` contract in `test_allocator_lifetime.cpp` are gated `#if !NOTE_NO_RESPONSE_RAII` — they pin behaviour the flag intentionally removes. Same gate added to the per-call overload tests in test_notecard.cpp / test_notecard_streaming.cpp.

AVR `avr-notecpp` size delta: default (RAII on):           27,404 B flash, 782 B RAM NOTE_NO_RESPONSE_RAII=1:     25,198 B flash, 773 B RAM → -2,206 B flash, -9 B RAM

The NO_RAII number matches the pre-Phase-1 avr_baselines.json entry exactly, confirming the full Phase 1 cost is recoverable on AVR.

Host test counts: default:                      1896 / 1896 pass NOTE_NO_RESPONSE_RAII=1:      1889 / 1889 pass (7 RAII tests gated) NOTE_SINGLETON=1:             1892 / 1893 (1 pre-existing failure) SINGLETON + NO_RAII:          1888 / 1889 (same pre-existing failure)

Author: m-mcgowan

src/note/api/card_attn.hpp

@@ -389,6 +389,7 @@ struct CardAttn {
             /// field will not be present when the attention pin is `LOW`.
             note::ResponseField<bool> set{};
 
+#if !NOTE_NO_RESPONSE_RAII
             /// Allocator that minted this Response's interned string fields,
             /// attached by Notecard execute paths when the Response is parsed.
             /// Empty == no cleanup needed (default-constructed Response, or a
@@ -421,6 +422,7 @@ struct CardAttn {
             }
             Response(const Response&) = delete;
             Response& operator=(const Response&) = delete;
+#endif // !NOTE_NO_RESPONSE_RAII
 
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
@@ -1700,6 +1702,7 @@ struct CardAttn {
             /// time) that the payload was stored by the Notecard.
             note::ResponseField<note::json_int_t> time{};
 
+#if !NOTE_NO_RESPONSE_RAII
             /// Allocator that minted this Response's interned string fields,
             /// attached by Notecard execute paths when the Response is parsed.
             /// Empty == no cleanup needed (default-constructed Response, or a
@@ -1731,6 +1734,7 @@ struct CardAttn {
             }
             Response(const Response&) = delete;
             Response& operator=(const Response&) = delete;
+#endif // !NOTE_NO_RESPONSE_RAII
 
 #if !NOTE_NO_JSON_TREE
             static Response parse(std::unique_ptr<JsonReader> reader_) {
@@ -2281,6 +2285,7 @@ struct CardAttn {
             /// field will not be present when the attention pin is `LOW`.
             note::ResponseField<bool> set{};
 
+#if !NOTE_NO_RESPONSE_RAII
             /// Allocator that minted this Response's interned string fields,
             /// attached by Notecard execute paths when the Response is parsed.
             /// Empty == no cleanup needed (default-constructed Response, or a
@@ -2306,6 +2311,7 @@ struct CardAttn {
             }
             Response(const Response&) = delete;
             Response& operator=(const Response&) = delete;
+#endif // !NOTE_NO_RESPONSE_RAII
 
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
@@ -2656,13 +2662,15 @@ inline ApiResult<typename CardAttn::Request::Response> CardAttn::Request::execut
     if (!rv_) return ::note::Unexpected(rv_.error());
     if (!nc_err_.empty()) return ApiResult<Response>(::note::ErrorInfo{::note::Error::Notecard, ::note::Cause::Unspecified, nc_err_.view()});
     if (exhausted_) return ApiResult<Response>(::note::ErrorInfo{::note::Error::Overflow, ::note::Cause::Unspecified, NOTE_ERR("arena exhausted")});
+#if !NOTE_NO_RESPONSE_RAII
     // The type-erased thunk couldn't reach `attach_allocator`. Mark the
     // Response as owning its interned strings so its dtor frees them on
     // the SINGLETON path (parity with the Notecard::execute template path,
     // which attaches via `detail::attach_allocator`). The dtor still gates
     // the actual free on `g_singleton_allocator_present`, so marking when
     // no allocator is configured stays safe.
     rsp_.alloc_.reset(::note::detail::g_singleton_allocator);
+#endif
     return ApiResult<Response>(std::move(rsp_));
 }
 inline Result<void> CardAttn::Request::command() const {
@@ -3192,13 +3200,15 @@ inline ApiResult<typename CardAttn::Retrieve::Response> CardAttn::Retrieve::exec
     if (!rv_) return ::note::Unexpected(rv_.error());
     if (!nc_err_.empty()) return ApiResult<Response>(::note::ErrorInfo{::note::Error::Notecard, ::note::Cause::Unspecified, nc_err_.view()});
     if (exhausted_) return ApiResult<Response>(::note::ErrorInfo{::note::Error::Overflow, ::note::Cause::Unspecified, NOTE_ERR("arena exhausted")});
+#if !NOTE_NO_RESPONSE_RAII
     // The type-erased thunk couldn't reach `attach_allocator`. Mark the
     // Response as owning its interned strings so its dtor frees them on
     // the SINGLETON path (parity with the Notecard::execute template path,
     // which attaches via `detail::attach_allocator`). The dtor still gates
     // the actual free on `g_singleton_allocator_present`, so marking when
     // no allocator is configured stays safe.
     rsp_.alloc_.reset(::note::detail::g_singleton_allocator);
+#endif
     return ApiResult<Response>(std::move(rsp_));
 }
 #endif
@@ -3416,13 +3426,15 @@ inline ApiResult<typename CardAttn::Query::Response> CardAttn::Query::execute()
     if (!rv_) return ::note::Unexpected(rv_.error());
     if (!nc_err_.empty()) return ApiResult<Response>(::note::ErrorInfo{::note::Error::Notecard, ::note::Cause::Unspecified, nc_err_.view()});
     if (exhausted_) return ApiResult<Response>(::note::ErrorInfo{::note::Error::Overflow, ::note::Cause::Unspecified, NOTE_ERR("arena exhausted")});
+#if !NOTE_NO_RESPONSE_RAII
     // The type-erased thunk couldn't reach `attach_allocator`. Mark the
     // Response as owning its interned strings so its dtor frees them on
     // the SINGLETON path (parity with the Notecard::execute template path,
     // which attaches via `detail::attach_allocator`). The dtor still gates
     // the actual free on `g_singleton_allocator_present`, so marking when
     // no allocator is configured stays safe.
     rsp_.alloc_.reset(::note::detail::g_singleton_allocator);
+#endif
     return ApiResult<Response>(std::move(rsp_));
 }
 #endif

src/note/api/card_aux.hpp

@@ -492,6 +492,7 @@ struct CardAux {
         note::ResponseField<bool> power{};
 #endif
 
+#if !NOTE_NO_RESPONSE_RAII
         /// Allocator that minted this Response's interned string fields,
         /// attached by Notecard execute paths when the Response is parsed.
         /// Empty == no cleanup needed (default-constructed Response, or a
@@ -523,6 +524,7 @@ struct CardAux {
         }
         Response(const Response&) = delete;
         Response& operator=(const Response&) = delete;
+#endif // !NOTE_NO_RESPONSE_RAII
 
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
@@ -960,13 +962,15 @@ inline ApiResult<typename CardAux::Response> CardAux::execute() const {
     if (!rv_) return ::note::Unexpected(rv_.error());
     if (!nc_err_.empty()) return ApiResult<Response>(::note::ErrorInfo{::note::Error::Notecard, ::note::Cause::Unspecified, nc_err_.view()});
     if (exhausted_) return ApiResult<Response>(::note::ErrorInfo{::note::Error::Overflow, ::note::Cause::Unspecified, NOTE_ERR("arena exhausted")});
+#if !NOTE_NO_RESPONSE_RAII
     // The type-erased thunk couldn't reach `attach_allocator`. Mark the
     // Response as owning its interned strings so its dtor frees them on
     // the SINGLETON path (parity with the Notecard::execute template path,
     // which attaches via `detail::attach_allocator`). The dtor still gates
     // the actual free on `g_singleton_allocator_present`, so marking when
     // no allocator is configured stays safe.
     rsp_.alloc_.reset(::note::detail::g_singleton_allocator);
+#endif
     return ApiResult<Response>(std::move(rsp_));
 }
 inline Result<void> CardAux::command() const {

src/note/api/card_aux_serial.hpp

@@ -294,6 +294,7 @@ struct CardAuxSerial {
             note::ResponseField<note::json_int_t> rate{};
 #endif
 
+#if !NOTE_NO_RESPONSE_RAII
             /// Allocator that minted this Response's interned string fields,
             /// attached by Notecard execute paths when the Response is parsed.
             /// Empty == no cleanup needed (default-constructed Response, or a
@@ -325,6 +326,7 @@ struct CardAuxSerial {
             }
             Response(const Response&) = delete;
             Response& operator=(const Response&) = delete;
+#endif // !NOTE_NO_RESPONSE_RAII
 
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
@@ -1382,13 +1384,15 @@ inline ApiResult<typename CardAuxSerial::Request::Response> CardAuxSerial::Reque
     if (!rv_) return ::note::Unexpected(rv_.error());
     if (!nc_err_.empty()) return ApiResult<Response>(::note::ErrorInfo{::note::Error::Notecard, ::note::Cause::Unspecified, nc_err_.view()});
     if (exhausted_) return ApiResult<Response>(::note::ErrorInfo{::note::Error::Overflow, ::note::Cause::Unspecified, NOTE_ERR("arena exhausted")});
+#if !NOTE_NO_RESPONSE_RAII
     // The type-erased thunk couldn't reach `attach_allocator`. Mark the
     // Response as owning its interned strings so its dtor frees them on
     // the SINGLETON path (parity with the Notecard::execute template path,
     // which attaches via `detail::attach_allocator`). The dtor still gates
     // the actual free on `g_singleton_allocator_present`, so marking when
     // no allocator is configured stays safe.
     rsp_.alloc_.reset(::note::detail::g_singleton_allocator);
+#endif
     return ApiResult<Response>(std::move(rsp_));
 }
 inline Result<void> CardAuxSerial::Request::command() const {

src/note/api/card_binary.hpp

@@ -130,6 +130,7 @@ struct CardBinary {
             /// Returns true if the Notecard is connected to the network.
             note::ResponseField<bool> connected{};
 
+#if !NOTE_NO_RESPONSE_RAII
             /// Allocator that minted this Response's interned string fields,
             /// attached by Notecard execute paths when the Response is parsed.
             /// Empty == no cleanup needed (default-constructed Response, or a
@@ -162,6 +163,7 @@ struct CardBinary {
             }
             Response(const Response&) = delete;
             Response& operator=(const Response&) = delete;
+#endif // !NOTE_NO_RESPONSE_RAII
 
 #if !NOTE_NO_JSON_TREE
             static Response parse(std::unique_ptr<JsonReader> reader_) {
@@ -416,6 +418,7 @@ struct CardBinary {
             /// Returns true if the Notecard is connected to the network.
             note::ResponseField<bool> connected{};
 
+#if !NOTE_NO_RESPONSE_RAII
             /// Allocator that minted this Response's interned string fields,
             /// attached by Notecard execute paths when the Response is parsed.
             /// Empty == no cleanup needed (default-constructed Response, or a
@@ -448,6 +451,7 @@ struct CardBinary {
             }
             Response(const Response&) = delete;
             Response& operator=(const Response&) = delete;
+#endif // !NOTE_NO_RESPONSE_RAII
 
 #if !NOTE_NO_JSON_TREE
             static Response parse(std::unique_ptr<JsonReader> reader_) {
@@ -680,13 +684,15 @@ inline ApiResult<typename CardBinary::Status::Response> CardBinary::Status::exec
     if (!rv_) return ::note::Unexpected(rv_.error());
     if (!nc_err_.empty()) return ApiResult<Response>(::note::ErrorInfo{::note::Error::Notecard, ::note::Cause::Unspecified, nc_err_.view()});
     if (exhausted_) return ApiResult<Response>(::note::ErrorInfo{::note::Error::Overflow, ::note::Cause::Unspecified, NOTE_ERR("arena exhausted")});
+#if !NOTE_NO_RESPONSE_RAII
     // The type-erased thunk couldn't reach `attach_allocator`. Mark the
     // Response as owning its interned strings so its dtor frees them on
     // the SINGLETON path (parity with the Notecard::execute template path,
     // which attaches via `detail::attach_allocator`). The dtor still gates
     // the actual free on `g_singleton_allocator_present`, so marking when
     // no allocator is configured stays safe.
     rsp_.alloc_.reset(::note::detail::g_singleton_allocator);
+#endif
     return ApiResult<Response>(std::move(rsp_));
 }
 inline Result<void> CardBinary::Status::command() const {
@@ -749,13 +755,15 @@ inline ApiResult<typename CardBinary::Clear::Response> CardBinary::Clear::execut
     if (!rv_) return ::note::Unexpected(rv_.error());
     if (!nc_err_.empty()) return ApiResult<Response>(::note::ErrorInfo{::note::Error::Notecard, ::note::Cause::Unspecified, nc_err_.view()});
     if (exhausted_) return ApiResult<Response>(::note::ErrorInfo{::note::Error::Overflow, ::note::Cause::Unspecified, NOTE_ERR("arena exhausted")});
+#if !NOTE_NO_RESPONSE_RAII
     // The type-erased thunk couldn't reach `attach_allocator`. Mark the
     // Response as owning its interned strings so its dtor frees them on
     // the SINGLETON path (parity with the Notecard::execute template path,
     // which attaches via `detail::attach_allocator`). The dtor still gates
     // the actual free on `g_singleton_allocator_present`, so marking when
     // no allocator is configured stays safe.
     rsp_.alloc_.reset(::note::detail::g_singleton_allocator);
+#endif
     return ApiResult<Response>(std::move(rsp_));
 }
 inline Result<void> CardBinary::Clear::command() const {

src/note/api/card_binary_get.hpp

@@ -147,6 +147,7 @@ struct CardBinaryGet : note::BinaryReceiveMixin {
         /// The MD5 checksum of the data returned, after it has been decoded
         note::ResponseField<note::string_view> status{};
 
+#if !NOTE_NO_RESPONSE_RAII
         /// Allocator that minted this Response's interned string fields,
         /// attached by Notecard execute paths when the Response is parsed.
         /// Empty == no cleanup needed (default-constructed Response, or a
@@ -179,6 +180,7 @@ struct CardBinaryGet : note::BinaryReceiveMixin {
         }
         Response(const Response&) = delete;
         Response& operator=(const Response&) = delete;
+#endif // !NOTE_NO_RESPONSE_RAII
 
 #if !NOTE_NO_JSON_TREE
         static Response parse(std::unique_ptr<JsonReader> reader_) {
@@ -395,13 +397,15 @@ inline ApiResult<typename CardBinaryGet::Response> CardBinaryGet::execute() cons
     if (!rv_) return ::note::Unexpected(rv_.error());
     if (!nc_err_.empty()) return ApiResult<Response>(::note::ErrorInfo{::note::Error::Notecard, ::note::Cause::Unspecified, nc_err_.view()});
     if (exhausted_) return ApiResult<Response>(::note::ErrorInfo{::note::Error::Overflow, ::note::Cause::Unspecified, NOTE_ERR("arena exhausted")});
+#if !NOTE_NO_RESPONSE_RAII
     // The type-erased thunk couldn't reach `attach_allocator`. Mark the
     // Response as owning its interned strings so its dtor frees them on
     // the SINGLETON path (parity with the Notecard::execute template path,
     // which attaches via `detail::attach_allocator`). The dtor still gates
     // the actual free on `g_singleton_allocator_present`, so marking when
     // no allocator is configured stays safe.
     rsp_.alloc_.reset(::note::detail::g_singleton_allocator);
+#endif
     return ApiResult<Response>(std::move(rsp_));
 }
 inline Result<void> CardBinaryGet::command() const {

src/note/api/card_binary_put.hpp

@@ -139,6 +139,7 @@ struct CardBinaryPut : note::BinarySendMixin {
         /// transmission
         note::ResponseField<note::string_view> err{};
 
+#if !NOTE_NO_RESPONSE_RAII
         /// Allocator that minted this Response's interned string fields,
         /// attached by Notecard execute paths when the Response is parsed.
         /// Empty == no cleanup needed (default-constructed Response, or a
@@ -170,6 +171,7 @@ struct CardBinaryPut : note::BinarySendMixin {
         }
         Response(const Response&) = delete;
         Response& operator=(const Response&) = delete;
+#endif // !NOTE_NO_RESPONSE_RAII
 
 #if !NOTE_NO_JSON_TREE
         static Response parse(std::unique_ptr<JsonReader> reader_) {
@@ -379,13 +381,15 @@ inline ApiResult<typename CardBinaryPut::Response> CardBinaryPut::execute() cons
     if (!rv_) return ::note::Unexpected(rv_.error());
     if (!nc_err_.empty()) return ApiResult<Response>(::note::ErrorInfo{::note::Error::Notecard, ::note::Cause::Unspecified, nc_err_.view()});
     if (exhausted_) return ApiResult<Response>(::note::ErrorInfo{::note::Error::Overflow, ::note::Cause::Unspecified, NOTE_ERR("arena exhausted")});
+#if !NOTE_NO_RESPONSE_RAII
     // The type-erased thunk couldn't reach `attach_allocator`. Mark the
     // Response as owning its interned strings so its dtor frees them on
     // the SINGLETON path (parity with the Notecard::execute template path,
     // which attaches via `detail::attach_allocator`). The dtor still gates
     // the actual free on `g_singleton_allocator_present`, so marking when
     // no allocator is configured stays safe.
     rsp_.alloc_.reset(::note::detail::g_singleton_allocator);
+#endif
     return ApiResult<Response>(std::move(rsp_));
 }
 inline Result<void> CardBinaryPut::command() const {

src/note/api/card_carrier.hpp

@@ -158,6 +158,7 @@ struct CardCarrier {
         /// Will display `true` when in `AUX_CHARGING` `"charging"` mode.
         note::ResponseField<bool> charging{};
 
+#if !NOTE_NO_RESPONSE_RAII
         /// Allocator that minted this Response's interned string fields,
         /// attached by Notecard execute paths when the Response is parsed.
         /// Empty == no cleanup needed (default-constructed Response, or a
@@ -189,6 +190,7 @@ struct CardCarrier {
         }
         Response(const Response&) = delete;
         Response& operator=(const Response&) = delete;
+#endif // !NOTE_NO_RESPONSE_RAII
 
 #if !NOTE_NO_JSON_TREE
         static Response parse(std::unique_ptr<JsonReader> reader_) {
@@ -383,13 +385,15 @@ inline ApiResult<typename CardCarrier::Response> CardCarrier::execute() const {
     if (!rv_) return ::note::Unexpected(rv_.error());
     if (!nc_err_.empty()) return ApiResult<Response>(::note::ErrorInfo{::note::Error::Notecard, ::note::Cause::Unspecified, nc_err_.view()});
     if (exhausted_) return ApiResult<Response>(::note::ErrorInfo{::note::Error::Overflow, ::note::Cause::Unspecified, NOTE_ERR("arena exhausted")});
+#if !NOTE_NO_RESPONSE_RAII
     // The type-erased thunk couldn't reach `attach_allocator`. Mark the
     // Response as owning its interned strings so its dtor frees them on
     // the SINGLETON path (parity with the Notecard::execute template path,
     // which attaches via `detail::attach_allocator`). The dtor still gates
     // the actual free on `g_singleton_allocator_present`, so marking when
     // no allocator is configured stays safe.
     rsp_.alloc_.reset(::note::detail::g_singleton_allocator);
+#endif
     return ApiResult<Response>(std::move(rsp_));
 }
 inline Result<void> CardCarrier::command() const {