diff --git a/include/msg/detail/indexed_builder_common.hpp b/include/msg/detail/indexed_builder_common.hpp
index d26c3cc9..2bc131fb 100644
--- a/include/msg/detail/indexed_builder_common.hpp
+++ b/include/msg/detail/indexed_builder_common.hpp
@@ -127,28 +127,26 @@ template <typename... Fields>
 using index_spec = decltype(stdx::make_indexed_tuple<get_field_type>(
     temp_index<Fields, 512, 256>{}...));
 
-template <template <typename, typename, typename, typename...> typename ParentT,
-          typename IndexSpec, typename CallbacksT, typename BaseMsgT,
-          typename... ExtraCallbackArgsT>
+template <template <typename, typename, typename, typename...> typename Parent,
+          typename IndexSpec, typename Callbacks, typename MsgBase,
+          typename... ExtraCallbackArgs>
 struct indexed_builder_base {
-    CallbacksT callbacks;
+    Callbacks callbacks;
 
     template <typename... Ts> [[nodiscard]] constexpr auto add(Ts... ts) {
         auto new_callbacks =
             stdx::tuple_cat(callbacks, separate_sum_terms(ts)...);
         using new_callbacks_t = decltype(new_callbacks);
-        return ParentT<IndexSpec, new_callbacks_t, BaseMsgT,
-                       ExtraCallbackArgsT...>{new_callbacks};
+        return Parent<IndexSpec, new_callbacks_t, MsgBase,
+                      ExtraCallbackArgs...>{new_callbacks};
     }
 
-    using callback_func_t = auto (*)(BaseMsgT const &,
-                                     ExtraCallbackArgsT... args) -> bool;
+    using callback_func_t = auto (*)(MsgBase const &,
+                                     ExtraCallbackArgs... args) -> bool;
 
     template <typename BuilderValue, std::size_t I>
-    constexpr static auto invoke_callback(BaseMsgT const &data,
-                                          ExtraCallbackArgsT... args) -> bool {
-        // FIXME: incomplete message callback invocation...
-        //        1) bit_cast message argument
+    constexpr static auto invoke_callback(MsgBase const &data,
+                                          ExtraCallbackArgs... args) -> bool {
         constexpr auto cb = IndexSpec{}.apply([&]<typename... Indices>(
                                                   Indices...) {
             constexpr auto orig_cb =
@@ -164,15 +162,14 @@ struct indexed_builder_base {
                 "Indexed callback has matcher that is never matched!");
         }
 
-        auto view = typename CB::msg_t::view_t{data};
-
-        if (cb.matcher(view)) {
+        using msg_t = typename CB::msg_t;
+        if (msg::call_with_message<msg_t>(cb.matcher, data)) {
             CIB_INFO(
                 "Incoming message matched [{}], because [{}] (collapsed to "
                 "[{}]), executing callback",
                 stdx::ct_string_to_type<cb.name, sc::string_constant>(),
                 orig_cb.matcher.describe(), cb.matcher.describe());
-            cb.callable(view, args...);
+            msg::call_with_message<msg_t>(cb.callable, data, args...);
             return true;
         }
         return false;
diff --git a/include/msg/detail/indexed_handler_common.hpp b/include/msg/detail/indexed_handler_common.hpp
index 742daaa2..000a40bc 100644
--- a/include/msg/detail/indexed_handler_common.hpp
+++ b/include/msg/detail/indexed_handler_common.hpp
@@ -2,10 +2,15 @@
 
 #include <log/log.hpp>
 #include <msg/handler_interface.hpp>
+#include <msg/message.hpp>
 
 #include <stdx/compiler.hpp>
 #include <stdx/ranges.hpp>
 
+#include <iterator>
+#include <type_traits>
+#include <utility>
+
 namespace msg {
 
 template <typename Field, typename Lookup> struct index {
@@ -23,30 +28,25 @@ template <typename Field, typename Lookup> struct index {
     }
 };
 
-template <typename BaseMsgT, typename... ExtraCallbackArgsT>
-struct callback_args_t {};
-
-template <typename BaseMsgT, typename... ExtraCallbackArgsT>
-constexpr callback_args_t<BaseMsgT, ExtraCallbackArgsT...> callback_args{};
+template <typename Index, typename Callbacks, typename MsgBase,
+          typename... ExtraCallbackArgs>
+struct indexed_handler : handler_interface<MsgBase, ExtraCallbackArgs...> {
+    Index index;
+    Callbacks callback_entries;
 
-template <typename IndexT, typename CallbacksT, typename BaseMsgT,
-          typename... ExtraCallbackArgsT>
-struct indexed_handler : handler_interface<BaseMsgT, ExtraCallbackArgsT...> {
-    IndexT index;
-    CallbacksT callback_entries;
+    template <typename Idx, typename CBs>
+    constexpr explicit indexed_handler(Idx &&idx, CBs &&cbs)
+        : index{std::forward<Idx>(idx)},
+          callback_entries{std::forward<CBs>(cbs)} {}
 
-    constexpr explicit indexed_handler(
-        callback_args_t<BaseMsgT, ExtraCallbackArgsT...>, IndexT new_index,
-        CallbacksT new_callbacks)
-        : index{new_index}, callback_entries{new_callbacks} {}
-
-    auto is_match(BaseMsgT const &msg) const -> bool final {
+    // This function may lie... it may claim to match when it doesn't because
+    // there are further conditions on the non-indexed parts of the matcher
+    auto is_match(MsgBase const &msg) const -> bool final {
         return not index(msg).none();
     }
 
     __attribute__((flatten)) auto
-    handle(BaseMsgT const &msg,
-           ExtraCallbackArgsT... args) const -> bool final {
+    handle(MsgBase const &msg, ExtraCallbackArgs... args) const -> bool final {
         auto const callback_candidates = index(msg);
 
         bool handled{};
@@ -60,4 +60,11 @@ struct indexed_handler : handler_interface<BaseMsgT, ExtraCallbackArgsT...> {
     }
 };
 
+template <typename MsgBase, typename... ExtraCallbackArgs>
+constexpr auto make_indexed_handler = []<typename Idx, typename CBs>(
+                                          Idx &&idx, CBs &&cbs) {
+    return indexed_handler<std::remove_cvref_t<Idx>, std::remove_cvref_t<CBs>,
+                           MsgBase, ExtraCallbackArgs...>{
+        std::forward<Idx>(idx), std::forward<CBs>(cbs)};
+};
 } // namespace msg
diff --git a/include/msg/handler.hpp b/include/msg/handler.hpp
index 2a86ec95..bd20d6c3 100644
--- a/include/msg/handler.hpp
+++ b/include/msg/handler.hpp
@@ -7,19 +7,19 @@
 
 namespace msg {
 
-template <typename Callbacks, typename BaseMsg, typename... ExtraCallbackArgs>
-struct handler : handler_interface<BaseMsg, ExtraCallbackArgs...> {
+template <typename Callbacks, typename MsgBase, typename... ExtraCallbackArgs>
+struct handler : handler_interface<MsgBase, ExtraCallbackArgs...> {
     Callbacks callbacks{};
 
     constexpr explicit handler(Callbacks new_callbacks)
         : callbacks{new_callbacks} {}
 
-    auto is_match(BaseMsg const &msg) const -> bool final {
+    auto is_match(MsgBase const &msg) const -> bool final {
         return stdx::any_of(
             [&](auto &callback) { return callback.is_match(msg); }, callbacks);
     }
 
-    auto handle(BaseMsg const &msg,
+    auto handle(MsgBase const &msg,
                 ExtraCallbackArgs... args) const -> bool final {
         auto const found_valid_callback = stdx::apply(
             [&](auto &...cbs) -> bool {
diff --git a/include/msg/handler_builder.hpp b/include/msg/handler_builder.hpp
index e2a421f6..41b4556a 100644
--- a/include/msg/handler_builder.hpp
+++ b/include/msg/handler_builder.hpp
@@ -6,21 +6,20 @@
 #include <stdx/tuple_algorithms.hpp>
 
 namespace msg {
-template <typename CallbacksT, typename BaseMsgT,
-          typename... ExtraCallbackArgsT>
+template <typename Callbacks, typename MsgBase, typename... ExtraCallbackArgs>
 struct handler_builder {
-    CallbacksT callbacks;
+    Callbacks callbacks;
 
     template <typename... Ts> [[nodiscard]] constexpr auto add(Ts... ts) {
         auto new_callbacks =
             stdx::tuple_cat(callbacks, stdx::make_tuple(ts...));
         using new_callbacks_t = decltype(new_callbacks);
-        return handler_builder<new_callbacks_t, BaseMsgT,
-                               ExtraCallbackArgsT...>{new_callbacks};
+        return handler_builder<new_callbacks_t, MsgBase, ExtraCallbackArgs...>{
+            new_callbacks};
     }
 
     template <typename BuilderValue> constexpr static auto build() {
-        return handler<CallbacksT, BaseMsgT, ExtraCallbackArgsT...>{
+        return handler<Callbacks, MsgBase, ExtraCallbackArgs...>{
             BuilderValue::value.callbacks};
     }
 };
diff --git a/include/msg/handler_interface.hpp b/include/msg/handler_interface.hpp
index 1b55f5c6..22387e8c 100644
--- a/include/msg/handler_interface.hpp
+++ b/include/msg/handler_interface.hpp
@@ -1,11 +1,11 @@
 #pragma once
 
 namespace msg {
-template <typename MsgBaseT, typename... ExtraCallbackArgsT>
+template <typename MsgBase, typename... ExtraCallbackArgs>
 struct handler_interface {
-    virtual auto is_match(MsgBaseT const &msg) const -> bool = 0;
+    virtual auto is_match(MsgBase const &msg) const -> bool = 0;
 
-    virtual auto handle(MsgBaseT const &msg,
-                        ExtraCallbackArgsT... extra_args) const -> bool = 0;
+    virtual auto handle(MsgBase const &msg,
+                        ExtraCallbackArgs... extra_args) const -> bool = 0;
 };
 } // namespace msg
diff --git a/include/msg/indexed_builder.hpp b/include/msg/indexed_builder.hpp
index ad326e2c..cbdd7c99 100644
--- a/include/msg/indexed_builder.hpp
+++ b/include/msg/indexed_builder.hpp
@@ -17,13 +17,13 @@
 
 namespace msg {
 // TODO: needs index configuration
-template <typename IndexSpec, typename CallbacksT, typename BaseMsgT,
-          typename... ExtraCallbackArgsT>
+template <typename IndexSpec, typename Callbacks, typename MsgBase,
+          typename... ExtraCallbackArgs>
 struct indexed_builder
-    : indexed_builder_base<indexed_builder, IndexSpec, CallbacksT, BaseMsgT,
-                           ExtraCallbackArgsT...> {
-    using base_t = indexed_builder_base<indexed_builder, IndexSpec, CallbacksT,
-                                        BaseMsgT, ExtraCallbackArgsT...>;
+    : indexed_builder_base<indexed_builder, IndexSpec, Callbacks, MsgBase,
+                           ExtraCallbackArgs...> {
+    using base_t = indexed_builder_base<indexed_builder, IndexSpec, Callbacks,
+                                        MsgBase, ExtraCallbackArgs...>;
 
     template <typename I, auto E>
     static CONSTEVAL auto get_entry(auto const &indices) {
@@ -73,14 +73,12 @@ struct indexed_builder
             });
 
         constexpr auto num_callbacks = BuilderValue::value.callbacks.size();
-        constexpr std::array<typename base_t::callback_func_t, num_callbacks>
-            callback_array =
-                base_t::template create_callback_array<BuilderValue>(
-                    std::make_index_sequence<num_callbacks>{});
+        constexpr auto callback_array =
+            base_t::template create_callback_array<BuilderValue>(
+                std::make_index_sequence<num_callbacks>{});
 
-        return indexed_handler{
-            callback_args_t<BaseMsgT, ExtraCallbackArgsT...>{}, baked_indices,
-            callback_array};
+        return make_indexed_handler<MsgBase, ExtraCallbackArgs...>(
+            baked_indices, callback_array);
     }
 };
 
diff --git a/include/msg/indexed_handler.hpp b/include/msg/indexed_handler.hpp
index f7833392..5ea965dc 100644
--- a/include/msg/indexed_handler.hpp
+++ b/include/msg/indexed_handler.hpp
@@ -6,12 +6,12 @@
 
 namespace msg {
 
-template <typename... IndicesT> struct indices : IndicesT... {
-    CONSTEVAL explicit indices(IndicesT... index_args)
-        : IndicesT{index_args}... {}
+template <typename... Indices> struct indices : Indices... {
+    CONSTEVAL explicit indices(Indices... index_args)
+        : Indices{index_args}... {}
 
     constexpr auto operator()(auto const &data) const {
-        return (this->IndicesT::operator()(data) & ...);
+        return (this->Indices::operator()(data) & ...);
     }
 };
 
diff --git a/include/msg/indexed_service.hpp b/include/msg/indexed_service.hpp
index 18b7dbba..a5c92009 100644
--- a/include/msg/indexed_service.hpp
+++ b/include/msg/indexed_service.hpp
@@ -7,10 +7,10 @@
 #include <stdx/tuple.hpp>
 
 namespace msg {
-template <typename IndexSpec, typename MsgBaseT, typename... ExtraCallbackArgsT>
+template <typename IndexSpec, typename MsgBase, typename... ExtraCallbackArgs>
 struct indexed_service
     : cib::builder_meta<
-          indexed_builder<IndexSpec, stdx::tuple<>, MsgBaseT,
-                          ExtraCallbackArgsT...>,
-          handler_interface<MsgBaseT, ExtraCallbackArgsT...> const *> {};
+          indexed_builder<IndexSpec, stdx::tuple<>, MsgBase,
+                          ExtraCallbackArgs...>,
+          handler_interface<MsgBase, ExtraCallbackArgs...> const *> {};
 } // namespace msg
diff --git a/include/msg/message.hpp b/include/msg/message.hpp
index 1035fcbe..9cf02d61 100644
--- a/include/msg/message.hpp
+++ b/include/msg/message.hpp
@@ -629,8 +629,8 @@ constexpr auto equivalent(O1 const &lhs, O2 const &rhs) {
 }
 
 template <typename Msg, typename F, typename S, typename... Args>
-constexpr auto call_with_message(F &&f, S &&s,
-                                 Args &&...args) -> decltype(auto) {
+__attribute__((flatten, always_inline)) constexpr auto
+call_with_message(F &&f, S &&s, Args &&...args) -> decltype(auto) {
     if constexpr (requires {
                       std::forward<F>(f)(std::forward<S>(s),
                                          std::forward<Args>(args)...);
diff --git a/include/msg/service.hpp b/include/msg/service.hpp
index 95e8d7ea..8497ba69 100644
--- a/include/msg/service.hpp
+++ b/include/msg/service.hpp
@@ -7,9 +7,9 @@
 #include <stdx/tuple.hpp>
 
 namespace msg {
-template <typename MsgBaseT, typename... ExtraCallbackArgsT>
+template <typename MsgBase, typename... ExtraCallbackArgs>
 struct service
     : cib::builder_meta<
-          handler_builder<stdx::tuple<>, MsgBaseT, ExtraCallbackArgsT...>,
-          handler_interface<MsgBaseT, ExtraCallbackArgsT...> const *> {};
+          handler_builder<stdx::tuple<>, MsgBase, ExtraCallbackArgs...>,
+          handler_interface<MsgBase, ExtraCallbackArgs...> const *> {};
 } // namespace msg
diff --git a/test/msg/indexed_builder.cpp b/test/msg/indexed_builder.cpp
index ebe12739..d891a045 100644
--- a/test/msg/indexed_builder.cpp
+++ b/test/msg/indexed_builder.cpp
@@ -28,7 +28,7 @@ using msg_defn = message<"test_msg", test_id_field, test_opcode_field,
                          test_field_2, test_field_3>;
 using test_msg_t = owning<msg_defn>;
 
-using index_spec = index_spec<test_id_field, test_opcode_field>;
+using index_spec = msg::index_spec<test_id_field, test_opcode_field>;
 struct test_service : indexed_service<index_spec, test_msg_t> {};
 
 bool callback_success;
@@ -423,3 +423,69 @@ TEST_CASE("handle extra arguments", "[indexed_builder]") {
     CHECK(callback_success);
     CHECK(callback_extra_arg == 42);
 }
+
+namespace {
+using base_storage_t = msg_defn::default_storage_t;
+struct raw_service : indexed_service<index_spec, base_storage_t> {};
+
+int callback_count{};
+
+constexpr auto raw_view_callback = callback<"raw view", msg_defn>(
+    msg::in<test_id_field, 0x80>,
+    [](msg::const_view<msg_defn>) { ++callback_count; });
+
+struct raw_view_project {
+    constexpr static auto config = cib::config(
+        cib::exports<raw_service>, cib::extend<raw_service>(raw_view_callback));
+};
+} // namespace
+
+TEST_CASE("handle raw message by view", "[indexed_builder]") {
+    cib::nexus<raw_view_project> test_nexus{};
+    test_nexus.init();
+
+    callback_count = 0;
+    CHECK(cib::service<raw_service>->handle(
+        std::array{0x8000ba11u, 0x0042d00du}));
+    CHECK(callback_count == 1);
+}
+
+namespace {
+constexpr auto raw_owning_callback = callback<"raw owning", msg_defn>(
+    msg::in<test_id_field, 0x80>,
+    [](msg::owning<msg_defn>) { ++callback_count; });
+
+struct raw_owning_project {
+    constexpr static auto config =
+        cib::config(cib::exports<raw_service>,
+                    cib::extend<raw_service>(raw_owning_callback));
+};
+} // namespace
+
+TEST_CASE("handle raw message by owning", "[indexed_builder]") {
+    cib::nexus<raw_owning_project> test_nexus{};
+    test_nexus.init();
+
+    callback_count = 0;
+    CHECK(cib::service<raw_service>->handle(
+        std::array{0x8000ba11u, 0x0042d00du}));
+    CHECK(callback_count == 1);
+}
+
+namespace {
+struct raw_mixed_project {
+    constexpr static auto config = cib::config(
+        cib::exports<raw_service>,
+        cib::extend<raw_service>(raw_view_callback, raw_owning_callback));
+};
+} // namespace
+
+TEST_CASE("handle raw message by mixture of callbacks", "[indexed_builder]") {
+    cib::nexus<raw_mixed_project> test_nexus{};
+    test_nexus.init();
+
+    callback_count = 0;
+    CHECK(cib::service<raw_service>->handle(
+        std::array{0x8000ba11u, 0x0042d00du}));
+    CHECK(callback_count == 2);
+}
diff --git a/test/msg/indexed_handler.cpp b/test/msg/indexed_handler.cpp
index f7efa39a..d4b18daf 100644
--- a/test/msg/indexed_handler.cpp
+++ b/test/msg/indexed_handler.cpp
@@ -24,14 +24,11 @@ using sub_opcode_field =
     msg::field<"sub_opcode_field",
                std::uint32_t>::located<at{0_dw, 15_msb, 0_lsb}>;
 
-using field_3 =
-    msg::field<"field_3", std::uint32_t>::located<at{1_dw, 23_msb, 16_lsb}>;
-
-using field_4 =
-    msg::field<"field_5", std::uint32_t>::located<at{1_dw, 15_msb, 0_lsb}>;
+using field2 = field<"f2", std::uint32_t>::located<at{1_dw, 23_msb, 16_lsb}>;
+using field3 = field<"f3", std::uint32_t>::located<at{1_dw, 15_msb, 0_lsb}>;
 
 using msg_defn =
-    message<"test_msg", opcode_field, sub_opcode_field, field_3, field_4>;
+    message<"test_msg", opcode_field, sub_opcode_field, field2, field3>;
 using test_msg = owning<msg_defn>;
 
 using callback_t = auto (*)(test_msg const &) -> bool;
@@ -42,17 +39,15 @@ bitset<32> callbacks_called{};
 } // namespace
 
 TEST_CASE("create empty handler", "[indexed_handler]") {
-    [[maybe_unused]] constexpr auto h = msg::indexed_handler{
-        msg::callback_args<test_msg>,
+    [[maybe_unused]] constexpr auto h = msg::make_indexed_handler<test_msg>(
         msg::indices{msg::index{
             opcode_field{}, lookup::make(CX_VALUE(
                                 lookup::input<std::uint32_t, bitset<32>>{}))}},
-        std::array<callback_t, 0>{}};
+        std::array<callback_t, 0>{});
 }
 
 TEST_CASE("create handler with one index and callback", "[indexed_handler]") {
-    constexpr auto h = msg::indexed_handler{
-        msg::callback_args<test_msg>,
+    constexpr auto h = msg::make_indexed_handler<test_msg>(
         msg::indices{msg::index{
             opcode_field{},
             lookup::make(CX_VALUE(lookup::input<std::uint32_t, bitset<32>, 1>{
@@ -61,7 +56,7 @@ TEST_CASE("create handler with one index and callback", "[indexed_handler]") {
         std::array<callback_t, 1>{[](test_msg const &) {
             callbacks_called.set(0);
             return true;
-        }}};
+        }});
 
     callbacks_called.reset();
     CHECK(h.handle(test_msg{"opcode_field"_field = 42}));
@@ -78,8 +73,7 @@ TEST_CASE("create handler with multiple indices and callbacks",
           "[indexed_handler]") {
     using lookup::entry;
 
-    constexpr auto h = msg::indexed_handler{
-        msg::callback_args<test_msg>,
+    constexpr auto h = msg::make_indexed_handler<test_msg>(
         msg::indices{
             msg::index{
                 opcode_field{},
@@ -136,7 +130,7 @@ TEST_CASE("create handler with multiple indices and callbacks",
                                   [](test_msg const &) {
                                       callbacks_called.set(8);
                                       return true;
-                                  }}};
+                                  }});
 
     auto const check_msg = [&](std::uint32_t op, std::uint32_t sub_op,
                                std::size_t callback_index) {
@@ -174,8 +168,7 @@ TEST_CASE("create handler with multiple indices and callbacks",
 }
 
 TEST_CASE("create handler with extra callback arg", "[indexed_handler]") {
-    constexpr auto h = msg::indexed_handler{
-        msg::callback_args<test_msg, std::size_t>,
+    constexpr auto h = msg::make_indexed_handler<test_msg, std::size_t>(
         msg::indices{msg::index{
             opcode_field{},
             lookup::make(CX_VALUE(lookup::input<std::uint32_t, bitset<32>, 1>{
@@ -185,10 +178,33 @@ TEST_CASE("create handler with extra callback arg", "[indexed_handler]") {
             [](test_msg const &, std::size_t i) {
                 callbacks_called.set(i);
                 return true;
-            }}};
+            }});
 
     callbacks_called.reset();
     CHECK(h.handle(test_msg{"opcode_field"_field = 42}, std::size_t{1}));
     CHECK(h.is_match(test_msg{"opcode_field"_field = 42}));
     CHECK(callbacks_called[1]);
 }
+
+TEST_CASE("separate handler input from callback parameter type",
+          "[indexed_handler]") {
+    using base_storage_t = msg_defn::default_storage_t;
+    using view_callback_t = auto (*)(msg::const_view<msg_defn>)->bool;
+
+    constexpr auto h = msg::make_indexed_handler<base_storage_t>(
+        msg::indices{msg::index{
+            opcode_field{},
+            lookup::make(CX_VALUE(lookup::input<std::uint32_t, bitset<32>, 1>{
+                bitset<32>{}, std::array{lookup::entry{
+                                  0x80u, bitset<32>{stdx::place_bits, 0}}}}))}},
+        std::array<view_callback_t, 1>{[](msg::const_view<msg_defn>) {
+            callbacks_called.set(0);
+            return true;
+        }});
+
+    callbacks_called.reset();
+    auto const msg_match = std::array{0x8000ba11u, 0x0042d00du};
+    CHECK(h.is_match(msg_match));
+    CHECK(h.handle(msg_match));
+    CHECK(callbacks_called[0]);
+}