refactor(io)!: replace erased callbacks with typed model events

crates/codegen/src/cxx_bridge.rs

@@ -583,7 +583,7 @@ fn emit_context_bridge(
                     );
                     inner.block_on(async {
                         let (#(#build_fields,)*) = #q::tokio::try_join!(
-                            #(inner.observer::<#build_event_tys>(options.clone()),)*
+                            #(inner.observer::<#build_event_tys>(&options),)*
                         )
                         .map_err(|e| e.to_string())?;
                         Ok::<_, String>((#(#build_wraps(#build_fields),)*))

crates/codegen/src/pyo3_bridge.rs

@@ -766,7 +766,7 @@ fn emit_context(
                         );
                         inner.block_on(async {
                             let (#(#build_fields,)*) = #q::tokio::try_join!(
-                                #(inner.observer::<#build_event_tys>(options.clone()),)*
+                                #(inner.observer::<#build_event_tys>(&options),)*
                             )
                             .map_err(|err| pyo3::exceptions::PyRuntimeError::new_err(err.to_string()))?;
                             Ok::<_, pyo3::PyErr>((#(#build_wraps(#build_fields),)*))

crates/instrumentation-build/example/build.rs

@@ -21,13 +21,10 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
 
     // Schema -> generated Rust instrumentation source.
     let opts = Options {
-        // To just print the events in this example, we'll be using the callback
-        // exporter. This exporter takes a type-erased event, so in order to
-        // simplify downcasting back to a statically-typed event, this features
-        // enables the generation of the "AnyEvent" helper type (see main.rs).
-        // This is typically left false when using "real" exporters.
-        any_event: true,
-        ..Default::default()
+        // Generate `DemoEvent`, which lets one typed callback receive events
+        // from every entity in the model.
+        umbrella_event: true,
+        ..Options::default()
     };
     let GenerateInfo { path, warnings } = generate(&parsed.schema, &opts)?;
 

crates/instrumentation-build/example/src/main.rs

@@ -1,18 +1,19 @@
 // SPDX-FileCopyrightText: Copyright (c) 2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
 // SPDX-License-Identifier: Apache-2.0
 
-use quent_instrumentation::{EventCallback, ExporterOptions};
+use quent_instrumentation::EventCallback;
 
-use crate::demo::{Connection, Context, Demo, Handle, Observer, Query, Server, Uuid};
+use crate::demo::{Connection, Context, Demo, DemoEvent, Handle, Observer, Query, Server, Uuid};
 
 #[allow(unused)]
 mod demo {
     include!(concat!(env!("OUT_DIR"), "/demo.rs"));
 }
 
 fn main() -> Result<(), Box<dyn std::error::Error>> {
-    // The context owns the exporter and exposes one observer per entity type.
-    let context: Context<Demo> = Context::try_new(Some(debug_printing_exporter()))?;
+    // The context builds one exporter pipeline per entity event type and
+    // exposes the corresponding typed observers.
+    let context: Context<Demo> = Context::try_new(println_exporter())?;
 
     // `observer.handle()` creates a fresh entity instance to events emit for.
     let mut server = context.observer::<Server>().handle();
@@ -71,11 +72,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
     Ok(())
 }
 
-/// Return an exporter that debug-prints each emitted event's payload.
-fn debug_printing_exporter() -> ExporterOptions {
-    ExporterOptions::Callback(EventCallback::new(|recorded| {
-        if let Some(event) = demo::AnyEvent::from_any(recorded.event.as_ref()) {
-            println!("{event:?}");
-        }
-    }))
+/// Return a callback that debug-prints each emitted event.
+fn println_exporter() -> EventCallback<DemoEvent> {
+    EventCallback::new(|event| println!("{event:?}"))
 }