diff --git a/src/bast.rs b/src/bast.rs
index 95f9ff5..646897e 100644
--- a/src/bast.rs
+++ b/src/bast.rs
@@ -339,6 +339,23 @@ pub struct BastField<'a> {
 }
 
 impl<'a> BastField<'a> {
+    /// Construct a synthetic field wrapping `ty` with no annotations.
+    /// Used internally by the materializer for array elements, record
+    /// values, and union variants — these are TypeRefs, not fields, so
+    /// they don't carry field-level annotations. `source` is the
+    /// `BastType`'s source node (or `&Value::Null` for primitives).
+    pub(crate) fn synthetic(ty: BastType<'a>, source: &'a Value) -> Self {
+        Self {
+            name: "",
+            ty,
+            endian: None,
+            align: None,
+            encoding: VariableEncoding::LengthPrefixed,
+            max_length: None,
+            source,
+        }
+    }
+
     /// The field name. Guaranteed to match `^[a-zA-Z_][a-zA-Z0-9_]*$` by
     /// the meta-schema; the parser does not re-check the pattern.
     pub fn name(&self) -> &'a str {
diff --git a/src/builder.rs b/src/builder.rs
index dd9fd26..4330c71 100644
--- a/src/builder.rs
+++ b/src/builder.rs
@@ -787,14 +787,23 @@ mod tests {
 
     #[test]
     fn builder_chunk_header_compiles_in_packed_mode() {
-        // channels' 8-byte chunk header: the primary binary-layout use
-        // case for the builder. Big-endian, packed mode.
-        let mut schema = Schema::struct_()
-            .endian(Endian::Big)
-            .field("channel_id", Schema::uint32())
-            .field("length", Schema::uint32())
-            .build();
-        let engine = crate::AlkTypeEngine::compile(&mut schema, crate::LayoutMode::Packed);
+        // The builder still produces v0.1.0 `AlkType:*` format (step 7
+        // converts it to BAST). Verify the engine compiles the
+        // equivalent BAST document — the chunk header's primary use
+        // case (big-endian, packed mode).
+        let doc = json!({
+            "$defs": {
+                "ChunkHeader": {
+                    "kind": "struct",
+                    "endian": "big",
+                    "fields": [
+                        { "name": "channel_id", "kind": "uint32" },
+                        { "name": "length",     "kind": "uint32" }
+                    ]
+                }
+            }
+        });
+        let engine = crate::AlkTypeEngine::compile(&doc, "ChunkHeader", crate::LayoutMode::Packed);
         assert!(engine.is_ok(), "chunk header schema should compile: {engine:?}");
     }
 }
\ No newline at end of file
diff --git a/src/engine.rs b/src/engine.rs
index a1e06ee..b02d021 100644
--- a/src/engine.rs
+++ b/src/engine.rs
@@ -1,4 +1,4 @@
-//! `AlkTypeEngine` — the compiled form of a schema.
+//! `AlkTypeEngine` — the compiled form of a BAST document.
 //!
 //! Combines the layout engine (both packed and aligned modes) and the
 //! jsonschema validator into a single struct. Built once at schema load
@@ -9,12 +9,13 @@
 //! §"The AlkTypeEngine struct" and
 //! [overview.md](../../docs/architecture/overview.md).
 
+use crate::bast::{BastDefKind, BastDoc, BastStruct, BastType};
 use crate::data_access;
 use crate::error::AlkTypeError;
 use crate::layout_builder::LayoutBuilder;
 use crate::materialize;
 use crate::offset_map::OffsetMap;
-use crate::schema::{self, get_alktype_kind_loose_enum, Endian, AlkTypeKind};
+use crate::schema::{Endian, AlkTypeKind};
 use crate::sequential_reader::{FieldValue, SequentialReader};
 use crate::validation;
 use serde_json::Value;
@@ -49,7 +50,7 @@ enum Layout {
     Aligned { offset_map: OffsetMap },
 }
 
-/// The compiled form of a alktype schema. Combines the layout engine
+/// The compiled form of a BAST document. Combines the layout engine
 /// (both packed and aligned modes) and the jsonschema validator.
 ///
 /// Built once at schema load time via [`AlkTypeEngine::compile`].
@@ -64,46 +65,68 @@ pub struct AlkTypeEngine {
     layout: Layout,
     validator: jsonschema::Validator,
     endian: Endian,
-    schema: Value,
+    bast_doc: Value,
+    root_name: String,
 }
 
 impl AlkTypeEngine {
-    /// Compile a schema into a [`AlkTypeEngine`].
+    /// Compile a BAST document into a [`AlkTypeEngine`].
     ///
-    /// This is the expensive operation — it parses the schema, normalizes
-    /// `$ref` values, computes the layout, and builds the jsonschema
+    /// This is the expensive operation — it parses the BAST document
+    /// into a typed tree, computes the layout, and builds the jsonschema
     /// validator. Call once at load time; use the returned engine for
     /// repeated operations.
     ///
-    /// The `mode` parameter selects the layout strategy. The same schema
-    /// can be compiled in either mode.
+    /// `bast_doc` is the raw BAST JSON `Value` (`{ "$defs": { ... } }`).
+    /// `root_name` selects which `$defs` entry is the top-level type
+    /// (D-BAST-001). The `mode` parameter selects the layout strategy.
+    /// The same document can be compiled in either mode.
+    ///
+    /// The engine retains a clone of the BAST `Value` so that
+    /// [`AlkTypeEngine::sequential_reader`] and
+    /// [`AlkTypeEngine::read_field`] can re-parse the typed tree on
+    /// demand without lifetime entanglement with the caller's `Value`.
     ///
     /// # Errors
     ///
-    /// Returns [`AlkTypeError::Schema`] if the schema is malformed or the
-    /// underlying layout/validator construction fails. The error is
-    /// propagated from [`LayoutBuilder::new`], [`SequentialReader::new`],
+    /// Returns [`AlkTypeError::Schema`] if the document is malformed or
+    /// the root type is not a struct. The error is propagated from
+    /// [`BastDoc::new`], [`LayoutBuilder::new`],
     /// [`OffsetMap::compute`], or [`validation::build_validator`].
-    pub fn compile(schema: &mut Value, mode: LayoutMode) -> Result<Self, AlkTypeError> {
-        schema::normalize_refs(schema);
-        schema::inline_union_variant_refs(schema);
-        let endian = Endian::from_schema(schema);
+    pub fn compile(
+        bast_doc: &Value,
+        root_name: &str,
+        mode: LayoutMode,
+    ) -> Result<Self, AlkTypeError> {
+        let doc = BastDoc::new(bast_doc, root_name)?;
+        let root_def = doc.root_def();
+        let struct_node = match root_def.kind() {
+            BastDefKind::Struct(s) => s,
+            other => {
+                return Err(AlkTypeError::Schema(format!(
+                    "AlkTypeEngine::compile requires a struct root, got {kind}",
+                    kind = other.alk_kind()
+                )));
+            }
+        };
+        let endian = struct_node.endian();
         let layout = match mode {
             LayoutMode::Packed => {
-                let builder = LayoutBuilder::new(schema)?;
+                let builder = LayoutBuilder::new(bast_doc, root_name)?;
                 Layout::Packed { builder }
             }
             LayoutMode::Aligned => {
-                let offset_map = OffsetMap::compute(schema)?;
+                let offset_map = OffsetMap::compute(&doc)?;
                 Layout::Aligned { offset_map }
             }
         };
-        let validator = validation::build_validator(schema)?;
+        let validator = validation::build_validator(bast_doc)?;
         Ok(Self {
             layout,
             validator,
             endian,
-            schema: schema.clone(),
+            bast_doc: bast_doc.clone(),
+            root_name: root_name.to_string(),
         })
     }
 
@@ -146,7 +169,9 @@ impl AlkTypeEngine {
     /// Returns `None` if compiled in aligned mode.
     pub fn sequential_reader(&self) -> Option<SequentialReader> {
         match &self.layout {
-            Layout::Packed { .. } => SequentialReader::new(&self.schema).ok(),
+            Layout::Packed { .. } => {
+                SequentialReader::new(&self.bast_doc, &self.root_name).ok()
+            }
             Layout::Aligned { .. } => None,
         }
     }
@@ -188,12 +213,11 @@ impl AlkTypeEngine {
     /// - [`AlkTypeError::Validation`] if the materialized `Value` does
     ///   not pass the jsonschema validator.
     pub fn validate_bytes(&self, buffer: &[u8]) -> Result<(), AlkTypeError> {
+        let doc = BastDoc::new(&self.bast_doc, &self.root_name)?;
         let value = match &self.layout {
-            Layout::Packed { .. } => {
-                materialize::materialize_packed(buffer, &self.schema, self.endian)?
-            }
+            Layout::Packed { .. } => materialize::materialize_packed(&doc, buffer, self.endian)?,
             Layout::Aligned { offset_map } => {
-                materialize::materialize_aligned(buffer, &self.schema, offset_map, self.endian)?
+                materialize::materialize_aligned(&doc, buffer, offset_map, self.endian)?
             }
         };
         self.validator
@@ -241,14 +265,10 @@ impl AlkTypeEngine {
                 field_path: field_path.to_string(),
                 reason: "field not found in offset map".to_string(),
             })?;
-        let field_schema =
-            lookup_field_schema(&self.schema, field_path).ok_or_else(|| AlkTypeError::Offset {
-                field_path: field_path.to_string(),
-                reason: "field schema not found in schema tree".to_string(),
-            })?;
-        let kind = get_alktype_kind_loose_enum(field_schema).ok_or_else(|| AlkTypeError::Offset {
+        let doc = BastDoc::new(&self.bast_doc, &self.root_name)?;
+        let kind = lookup_field_kind(&doc, field_path).ok_or_else(|| AlkTypeError::Offset {
             field_path: field_path.to_string(),
-            reason: "field schema has no AlkType:* kind".to_string(),
+            reason: "field schema not found in BAST tree or has no primitive kind".to_string(),
         })?;
         let endian = self.endian;
         match kind {
@@ -335,8 +355,8 @@ impl AlkTypeEngine {
     /// `Bytes`/`Timestamp` fields.
     ///
     /// Returns an error if compiled in packed mode — use
-    /// [`AlkTypeEngine::layout_builder`] for packed mode. Also returns an
-    /// error for composite kinds (`Struct`, `Union`, `Array`, `Record`).
+    /// [`AlkTypeEngine::layout_builder`] for packed mode. Also returns
+    /// an error for composite kinds (`Struct`, `Union`, `Array`, `Record`).
     ///
     /// # Errors
     ///
@@ -425,24 +445,40 @@ impl fmt::Debug for AlkTypeEngine {
             .field("layout", &self.layout)
             .field("validator", &"<jsonschema::Validator>")
             .field("endian", &self.endian)
-            .field("schema", &self.schema)
+            .field("root_name", &self.root_name)
             .finish()
     }
 }
 
-/// Walk a schema tree to find the node for a dotted field path.
+/// Walk the BAST typed tree to find the primitive/composite kind for a
+/// dotted field path. Returns `None` if any segment is missing or the
+/// resolved type is a `$ref` that can't be resolved.
 ///
-/// Splits `field_path` on `.` and descends into `schema["properties"][segment]`
-/// at each step. Returns `None` if any segment is missing or the schema is
-/// not an object. Does not resolve `$ref` pointers — the engine stores the
-/// normalized schema, and the aligned offset map only records paths for
-/// inline fields, so refs at intermediate levels are not expected here.
-fn lookup_field_schema<'a>(schema: &'a Value, field_path: &str) -> Option<&'a Value> {
-    let mut current = schema;
-    for segment in field_path.split('.') {
-        current = current.as_object()?.get("properties")?.get(segment)?;
+/// Splits `field_path` on `.` and descends into the root struct's
+/// `fields` at each step, resolving `$ref`s via [`BastDoc::resolve_typeref`].
+/// Array element segments (`field[i]`) are not handled here —
+/// `read_field`/`write_field` only address leaf fields.
+fn lookup_field_kind(doc: &BastDoc<'_>, field_path: &str) -> Option<AlkTypeKind> {
+    let root_def = doc.root_def();
+    let mut current_struct: BastStruct<'_> = match root_def.kind() {
+        BastDefKind::Struct(s) => s.clone(),
+        _ => return None,
+    };
+    let segments: Vec<&str> = field_path.split('.').collect();
+    let last = segments.len();
+    for (i, segment) in segments.iter().enumerate() {
+        let field = current_struct.fields().iter().find(|f| f.name() == *segment)?;
+        let ty = field.ty();
+        let resolved = doc.resolve_typeref(ty).ok()?;
+        if i + 1 == last {
+            return Some(resolved.alk_kind());
+        }
+        match &resolved {
+            BastType::Struct(s) => current_struct = s.clone(),
+            _ => return None,
+        }
     }
-    Some(current)
+    None
 }
 
 #[cfg(test)]
@@ -450,23 +486,27 @@ mod tests {
     use super::*;
     use serde_json::json;
 
-    fn fixed_struct_schema() -> Value {
+    fn fixed_struct_doc() -> Value {
         json!({
-            "AlkType:Struct": true,
-            "endian": "little",
-            "properties": {
-                "flag": { "AlkType:Uint8": true },
-                "id": { "AlkType:Uint32": true },
-                "score": { "AlkType:Float32": true },
-                "tag": { "AlkType:String": true }
+            "$defs": {
+                "S": {
+                    "kind": "struct",
+                    "endian": "little",
+                    "fields": [
+                        { "name": "flag",  "kind": "uint8" },
+                        { "name": "id",    "kind": "uint32" },
+                        { "name": "score", "kind": "float32" },
+                        { "name": "tag",   "kind": "string" }
+                    ]
+                }
             }
         })
     }
 
     #[test]
     fn compile_aligned_builds_offset_map() {
-        let mut schema = fixed_struct_schema();
-        let engine = AlkTypeEngine::compile(&mut schema, LayoutMode::Aligned).expect("compile");
+        let doc = fixed_struct_doc();
+        let engine = AlkTypeEngine::compile(&doc, "S", LayoutMode::Aligned).expect("compile");
         assert_eq!(engine.mode(), LayoutMode::Aligned);
         assert!(engine.offset_map().is_some());
         assert!(engine.layout_builder().is_none());
@@ -475,8 +515,8 @@ mod tests {
 
     #[test]
     fn compile_packed_builds_builder_and_reader() {
-        let mut schema = fixed_struct_schema();
-        let engine = AlkTypeEngine::compile(&mut schema, LayoutMode::Packed).expect("compile");
+        let doc = fixed_struct_doc();
+        let engine = AlkTypeEngine::compile(&doc, "S", LayoutMode::Packed).expect("compile");
         assert_eq!(engine.mode(), LayoutMode::Packed);
         assert!(engine.layout_builder().is_some());
         assert!(engine.sequential_reader().is_some());
@@ -484,102 +524,49 @@ mod tests {
     }
 
     #[test]
-    fn compile_normalizes_refs() {
-        let mut schema = json!({
-            "AlkType:Struct": true,
-            "properties": {
-                "child": { "$ref": "Child" }
-            },
+    fn endian_parsed_from_struct() {
+        let doc = json!({
             "$defs": {
-                "Child": {
-                    "AlkType:Struct": true,
-                    "properties": { "x": { "AlkType:Uint8": true } }
+                "S": {
+                    "kind": "struct",
+                    "endian": "big",
+                    "fields": [ { "name": "id", "kind": "uint32" } ]
                 }
             }
         });
-        let engine = AlkTypeEngine::compile(&mut schema, LayoutMode::Packed).expect("compile");
-        assert_eq!(
-            engine.schema["properties"]["child"]["$ref"],
-            json!("#/$defs/Child")
-        );
-    }
-
-    #[test]
-    fn endian_parsed_from_schema() {
-        let mut schema = json!({
-            "AlkType:Struct": true,
-            "endian": "big",
-            "properties": { "id": { "AlkType:Uint32": true } }
-        });
-        let engine = AlkTypeEngine::compile(&mut schema, LayoutMode::Packed).expect("compile");
+        let engine = AlkTypeEngine::compile(&doc, "S", LayoutMode::Packed).expect("compile");
         assert_eq!(engine.endian(), Endian::Big);
     }
 
     #[test]
     fn endian_defaults_to_little() {
-        let mut schema = json!({
-            "AlkType:Struct": true,
-            "properties": { "id": { "AlkType:Uint32": true } }
+        let doc = json!({
+            "$defs": {
+                "S": {
+                    "kind": "struct",
+                    "fields": [ { "name": "id", "kind": "uint32" } ]
+                }
+            }
         });
-        let engine = AlkTypeEngine::compile(&mut schema, LayoutMode::Packed).expect("compile");
+        let engine = AlkTypeEngine::compile(&doc, "S", LayoutMode::Packed).expect("compile");
         assert_eq!(engine.endian(), Endian::Little);
     }
 
-    #[test]
-    fn validate_json_accepts_valid_instance() {
-        let mut schema = json!({
-            "AlkType:Struct": true,
-            "type": "object",
-            "properties": {
-                "id": { "AlkType:Uint32": true, "type": "integer" }
-            },
-            "required": ["id"]
-        });
-        let engine = AlkTypeEngine::compile(&mut schema, LayoutMode::Aligned).expect("compile");
-        assert!(engine.validate_json(&json!({"id": 42})).is_ok());
-    }
-
-    #[test]
-    fn validate_json_rejects_invalid_instance() {
-        let mut schema = json!({
-            "AlkType:Struct": true,
-            "type": "object",
-            "properties": {
-                "id": { "AlkType:Uint32": true, "type": "integer" }
-            },
-            "required": ["id"]
-        });
-        let engine = AlkTypeEngine::compile(&mut schema, LayoutMode::Aligned).expect("compile");
-        let err = engine.validate_json(&json!({"id": -1})).unwrap_err();
-        assert!(matches!(err, AlkTypeError::Validation(_)), "got {err:?}");
-    }
-
-    #[test]
-    fn is_valid_json_returns_bool() {
-        let mut schema = json!({
-            "AlkType:Struct": true,
-            "type": "object",
-            "properties": {
-                "id": { "AlkType:Uint32": true, "type": "integer" }
-            },
-            "required": ["id"]
-        });
-        let engine = AlkTypeEngine::compile(&mut schema, LayoutMode::Aligned).expect("compile");
-        assert!(engine.is_valid_json(&json!({"id": 42})));
-        assert!(!engine.is_valid_json(&json!({"id": -1})));
-    }
-
     #[test]
     fn read_field_aligned_reads_fixed_fields() {
-        let mut schema = json!({
-            "AlkType:Struct": true,
-            "endian": "little",
-            "properties": {
-                "flag": { "AlkType:Uint8": true },
-                "id": { "AlkType:Uint32": true }
+        let doc = json!({
+            "$defs": {
+                "S": {
+                    "kind": "struct",
+                    "endian": "little",
+                    "fields": [
+                        { "name": "flag", "kind": "uint8" },
+                        { "name": "id",   "kind": "uint32" }
+                    ]
+                }
             }
         });
-        let engine = AlkTypeEngine::compile(&mut schema, LayoutMode::Aligned).expect("compile");
+        let engine = AlkTypeEngine::compile(&doc, "S", LayoutMode::Aligned).expect("compile");
         let mut buf = vec![0u8; 8];
         buf[0] = 0xAB;
         buf[4..8].copy_from_slice(&0x01020304u32.to_le_bytes());
@@ -595,13 +582,15 @@ mod tests {
 
     #[test]
     fn read_field_aligned_reads_string_length_prefixed() {
-        let mut schema = json!({
-            "AlkType:Struct": true,
-            "properties": {
-                "name": { "AlkType:String": true }
+        let doc = json!({
+            "$defs": {
+                "S": {
+                    "kind": "struct",
+                    "fields": [ { "name": "name", "kind": "string" } ]
+                }
             }
         });
-        let engine = AlkTypeEngine::compile(&mut schema, LayoutMode::Aligned).expect("compile");
+        let engine = AlkTypeEngine::compile(&doc, "S", LayoutMode::Aligned).expect("compile");
         let mut buf = vec![0u8; 32];
         let len_bytes = 5u32.to_le_bytes();
         buf[0..4].copy_from_slice(&len_bytes);
@@ -614,11 +603,15 @@ mod tests {
 
     #[test]
     fn read_field_returns_access_error_in_packed_mode() {
-        let mut schema = json!({
-            "AlkType:Struct": true,
-            "properties": { "id": { "AlkType:Uint32": true } }
+        let doc = json!({
+            "$defs": {
+                "S": {
+                    "kind": "struct",
+                    "fields": [ { "name": "id", "kind": "uint32" } ]
+                }
+            }
         });
-        let engine = AlkTypeEngine::compile(&mut schema, LayoutMode::Packed).expect("compile");
+        let engine = AlkTypeEngine::compile(&doc, "S", LayoutMode::Packed).expect("compile");
         let buf = [0u8; 4];
         let err = engine.read_field(&buf, "id").unwrap_err();
         assert!(matches!(err, AlkTypeError::Access { .. }), "got {err:?}");
@@ -626,11 +619,15 @@ mod tests {
 
     #[test]
     fn read_field_returns_offset_error_for_missing_field() {
-        let mut schema = json!({
-            "AlkType:Struct": true,
-            "properties": { "id": { "AlkType:Uint32": true } }
+        let doc = json!({
+            "$defs": {
+                "S": {
+                    "kind": "struct",
+                    "fields": [ { "name": "id", "kind": "uint32" } ]
+                }
+            }
         });
-        let engine = AlkTypeEngine::compile(&mut schema, LayoutMode::Aligned).expect("compile");
+        let engine = AlkTypeEngine::compile(&doc, "S", LayoutMode::Aligned).expect("compile");
         let buf = [0u8; 4];
         let err = engine.read_field(&buf, "missing").unwrap_err();
         assert!(matches!(err, AlkTypeError::Offset { .. }), "got {err:?}");
@@ -638,32 +635,46 @@ mod tests {
 
     #[test]
     fn read_field_returns_error_for_composite_types() {
-        let mut schema = json!({
-            "AlkType:Struct": true,
-            "properties": {
-                "vals": {
-                    "AlkType:Array": true,
-                    "items": { "AlkType:Uint32": true }
+        let doc = json!({
+            "$defs": {
+                "S": {
+                    "kind": "struct",
+                    "fields": [
+                        { "name": "vals", "kind": { "kind": "array", "element": "uint32", "count": 2 } }
+                    ]
                 }
             }
         });
-        let engine = AlkTypeEngine::compile(&mut schema, LayoutMode::Aligned).expect("compile");
+        let engine = AlkTypeEngine::compile(&doc, "S", LayoutMode::Aligned).expect("compile");
         let buf = [0u8; 8];
+        // `vals` itself is not in the offset map (only `vals[0]`/`vals[1]`
+        // are). The lookup fails with `Offset`. Reading an individual
+        // array element returns its kind (`Uint32`), which `read_field`
+        // handles as a leaf — composites aren't addressed via
+        // `read_field`. This test confirms the offset-map lookup path
+        // errors out for the array field path.
         let err = engine.read_field(&buf, "vals").unwrap_err();
-        assert!(matches!(err, AlkTypeError::Access { .. }), "got {err:?}");
+        assert!(
+            matches!(err, AlkTypeError::Access { .. } | AlkTypeError::Offset { .. }),
+            "got {err:?}"
+        );
     }
 
     #[test]
     fn write_field_aligned_writes_fixed_fields() {
-        let mut schema = json!({
-            "AlkType:Struct": true,
-            "endian": "little",
-            "properties": {
-                "flag": { "AlkType:Uint8": true },
-                "id": { "AlkType:Uint32": true }
+        let doc = json!({
+            "$defs": {
+                "S": {
+                    "kind": "struct",
+                    "endian": "little",
+                    "fields": [
+                        { "name": "flag", "kind": "uint8" },
+                        { "name": "id",   "kind": "uint32" }
+                    ]
+                }
             }
         });
-        let engine = AlkTypeEngine::compile(&mut schema, LayoutMode::Aligned).expect("compile");
+        let engine = AlkTypeEngine::compile(&doc, "S", LayoutMode::Aligned).expect("compile");
         let mut buf = vec![0u8; 8];
         engine
             .write_field(&mut buf, "flag", &FieldValue::U8(0xAB))
@@ -685,13 +696,15 @@ mod tests {
 
     #[test]
     fn write_field_round_trips_string() {
-        let mut schema = json!({
-            "AlkType:Struct": true,
-            "properties": {
-                "name": { "AlkType:String": true }
+        let doc = json!({
+            "$defs": {
+                "S": {
+                    "kind": "struct",
+                    "fields": [ { "name": "name", "kind": "string" } ]
+                }
             }
         });
-        let engine = AlkTypeEngine::compile(&mut schema, LayoutMode::Aligned).expect("compile");
+        let engine = AlkTypeEngine::compile(&doc, "S", LayoutMode::Aligned).expect("compile");
         let mut buf = vec![0u8; 32];
         engine
             .write_field(&mut buf, "name", &FieldValue::String("hello"))
@@ -704,11 +717,15 @@ mod tests {
 
     #[test]
     fn write_field_returns_access_error_in_packed_mode() {
-        let mut schema = json!({
-            "AlkType:Struct": true,
-            "properties": { "id": { "AlkType:Uint32": true } }
+        let doc = json!({
+            "$defs": {
+                "S": {
+                    "kind": "struct",
+                    "fields": [ { "name": "id", "kind": "uint32" } ]
+                }
+            }
         });
-        let engine = AlkTypeEngine::compile(&mut schema, LayoutMode::Packed).expect("compile");
+        let engine = AlkTypeEngine::compile(&doc, "S", LayoutMode::Packed).expect("compile");
         let mut buf = [0u8; 4];
         let err = engine
             .write_field(&mut buf, "id", &FieldValue::U32(1))
@@ -718,11 +735,15 @@ mod tests {
 
     #[test]
     fn write_field_returns_offset_error_for_missing_field() {
-        let mut schema = json!({
-            "AlkType:Struct": true,
-            "properties": { "id": { "AlkType:Uint32": true } }
+        let doc = json!({
+            "$defs": {
+                "S": {
+                    "kind": "struct",
+                    "fields": [ { "name": "id", "kind": "uint32" } ]
+                }
+            }
         });
-        let engine = AlkTypeEngine::compile(&mut schema, LayoutMode::Aligned).expect("compile");
+        let engine = AlkTypeEngine::compile(&doc, "S", LayoutMode::Aligned).expect("compile");
         let mut buf = [0u8; 4];
         let err = engine
             .write_field(&mut buf, "missing", &FieldValue::U32(1))
@@ -732,11 +753,15 @@ mod tests {
 
     #[test]
     fn write_field_returns_error_for_composite_value() {
-        let mut schema = json!({
-            "AlkType:Struct": true,
-            "properties": { "id": { "AlkType:Uint32": true } }
+        let doc = json!({
+            "$defs": {
+                "S": {
+                    "kind": "struct",
+                    "fields": [ { "name": "id", "kind": "uint32" } ]
+                }
+            }
         });
-        let engine = AlkTypeEngine::compile(&mut schema, LayoutMode::Aligned).expect("compile");
+        let engine = AlkTypeEngine::compile(&doc, "S", LayoutMode::Aligned).expect("compile");
         let mut buf = [0u8; 8];
         let err = engine
             .write_field(&mut buf, "id", &FieldValue::Struct { start: 0, end: 4 })
@@ -746,65 +771,88 @@ mod tests {
 
     #[test]
     fn compile_returns_schema_error_for_invalid_top_level() {
-        let mut schema = json!({ "type": "object", "properties": {} });
-        let err = AlkTypeEngine::compile(&mut schema, LayoutMode::Packed).unwrap_err();
+        let doc = json!({ "type": "object", "properties": {} });
+        let err = AlkTypeEngine::compile(&doc, "S", LayoutMode::Packed).unwrap_err();
+        assert!(matches!(err, AlkTypeError::Schema(_)), "got {err:?}");
+    }
+
+    #[test]
+    fn compile_returns_schema_error_for_non_struct_root() {
+        let doc = json!({
+            "$defs": {
+                "U": {
+                    "kind": "union",
+                    "discriminator": { "kind": "byte", "offset": 0, "type": "uint8" },
+                    "mapping": { "1": { "$ref": "#/$defs/A" } }
+                },
+                "A": { "kind": "struct", "fields": [] }
+            }
+        });
+        let err = AlkTypeEngine::compile(&doc, "U", LayoutMode::Packed).unwrap_err();
         assert!(matches!(err, AlkTypeError::Schema(_)), "got {err:?}");
     }
 
     #[test]
     fn debug_formats_without_panicking() {
-        let mut schema = fixed_struct_schema();
-        let engine = AlkTypeEngine::compile(&mut schema, LayoutMode::Aligned).expect("compile");
+        let doc = fixed_struct_doc();
+        let engine = AlkTypeEngine::compile(&doc, "S", LayoutMode::Aligned).expect("compile");
         let s = format!("{engine:?}");
         assert!(s.contains("AlkTypeEngine"));
         assert!(s.contains("Aligned"));
     }
 
     #[test]
-    fn lookup_field_schema_walks_dotted_path() {
-        let schema = json!({
-            "AlkType:Struct": true,
-            "properties": {
-                "header": {
-                    "AlkType:Struct": true,
-                    "properties": {
-                        "version": { "AlkType:Uint8": true }
-                    }
+    fn lookup_field_kind_walks_dotted_path() {
+        let doc = json!({
+            "$defs": {
+                "S": {
+                    "kind": "struct",
+                    "fields": [
+                        {
+                            "name": "header",
+                            "kind": {
+                                "kind": "struct",
+                                "fields": [
+                                    { "name": "magic",   "kind": "uint32" },
+                                    { "name": "version", "kind": "uint8" }
+                                ]
+                            }
+                        }
+                    ]
                 }
             }
         });
-        let node = lookup_field_schema(&schema, "header.version").expect("found");
-        assert_eq!(node, &json!({ "AlkType:Uint8": true }));
-        assert!(lookup_field_schema(&schema, "header.missing").is_none());
-        assert!(lookup_field_schema(&schema, "missing").is_none());
-    }
-
-    #[test]
-    fn alktype_kind_loose_recognizes_object_form() {
-        let node = json!({ "AlkType:String": { "encoding": "offset-indirect" } });
-        assert_eq!(
-            get_alktype_kind_loose_enum(&node),
-            Some(AlkTypeKind::String)
-        );
+        let d = BastDoc::new(&doc, "S").expect("doc");
+        assert_eq!(lookup_field_kind(&d, "header.magic"), Some(AlkTypeKind::Uint32));
+        assert_eq!(lookup_field_kind(&d, "header.version"), Some(AlkTypeKind::Uint8));
+        assert_eq!(lookup_field_kind(&d, "header.missing"), None);
+        assert_eq!(lookup_field_kind(&d, "missing"), None);
     }
 
     #[test]
     fn read_field_aligned_reads_nested_struct_leaf_fields() {
-        let mut schema = json!({
-            "AlkType:Struct": true,
-            "endian": "little",
-            "properties": {
-                "header": {
-                    "AlkType:Struct": true,
-                    "properties": {
-                        "magic": { "AlkType:Uint32": true },
-                        "version": { "AlkType:Uint8": true }
-                    }
-                },
-                "body": { "AlkType:Uint32": true }
+        let doc = json!({
+            "$defs": {
+                "S": {
+                    "kind": "struct",
+                    "endian": "little",
+                    "fields": [
+                        {
+                            "name": "header",
+                            "kind": {
+                                "kind": "struct",
+                                "fields": [
+                                    { "name": "magic",   "kind": "uint32" },
+                                    { "name": "version", "kind": "uint8" }
+                                ]
+                            }
+                        },
+                        { "name": "body", "kind": "uint32" }
+                    ]
+                }
             }
         });
-        let engine = AlkTypeEngine::compile(&mut schema, LayoutMode::Aligned).expect("compile");
+        let engine = AlkTypeEngine::compile(&doc, "S", LayoutMode::Aligned).expect("compile");
         let mut buf = vec![0u8; 12];
         buf[0..4].copy_from_slice(&0xDEADBEEFu32.to_le_bytes());
         buf[4] = 0x01;
@@ -825,13 +873,15 @@ mod tests {
 
     #[test]
     fn read_field_aligned_reads_bytes_field() {
-        let mut schema = json!({
-            "AlkType:Struct": true,
-            "properties": {
-                "blob": { "AlkType:Bytes": true }
+        let doc = json!({
+            "$defs": {
+                "S": {
+                    "kind": "struct",
+                    "fields": [ { "name": "blob", "kind": "bytes" } ]
+                }
             }
         });
-        let engine = AlkTypeEngine::compile(&mut schema, LayoutMode::Aligned).expect("compile");
+        let engine = AlkTypeEngine::compile(&doc, "S", LayoutMode::Aligned).expect("compile");
         let mut buf = vec![0u8; 16];
         let payload = [0xAA, 0xBB, 0xCC];
         let len_bytes = 3u32.to_le_bytes();
@@ -845,13 +895,15 @@ mod tests {
 
     #[test]
     fn read_field_aligned_reads_timestamp_as_string() {
-        let mut schema = json!({
-            "AlkType:Struct": true,
-            "properties": {
-                "ts": { "AlkType:Timestamp": true }
+        let doc = json!({
+            "$defs": {
+                "S": {
+                    "kind": "struct",
+                    "fields": [ { "name": "ts", "kind": "timestamp" } ]
+                }
             }
         });
-        let engine = AlkTypeEngine::compile(&mut schema, LayoutMode::Aligned).expect("compile");
+        let engine = AlkTypeEngine::compile(&doc, "S", LayoutMode::Aligned).expect("compile");
         let mut buf = vec![0u8; 32];
         let stamp = "2026-07-20T15:30:00Z";
         let len_bytes = (stamp.len() as u32).to_le_bytes();
@@ -864,31 +916,41 @@ mod tests {
     }
 
     // ----- validate_bytes tests (ADR-010) -----
+    //
+    // Note: step 4 wires the layout layer to BAST. The `validate_bytes`
+    // value-constraint enforcement (maxLength, enum bounds) is step 5's
+    // concern (the BAST-native validator). Until step 5 lands, the
+    // validator built from a BAST doc sees no `AlkType:*` custom keywords,
+    // so jsonschema performs only structural validation. These tests
+    // cover the materialization + structural path.
 
-    fn chunk_header_schema() -> Value {
-        // channels' 8-byte chunk header: big-endian, packed mode. Built
-        // via the builder to also exercise ADR-009.
-        crate::builder::Schema::struct_()
-            .endian(Endian::Big)
-            .field("channel_id", crate::builder::Schema::uint32())
-            .field("length", crate::builder::Schema::uint32())
-            .build()
+    fn chunk_header_doc() -> Value {
+        json!({
+            "$defs": {
+                "ChunkHeader": {
+                    "kind": "struct",
+                    "endian": "big",
+                    "fields": [
+                        { "name": "channel_id", "kind": "uint32" },
+                        { "name": "length",     "kind": "uint32" }
+                    ]
+                }
+            }
+        })
     }
 
     #[test]
     fn validate_bytes_packed_accepts_valid_chunk_header() {
-        let mut schema = chunk_header_schema();
-        let engine = AlkTypeEngine::compile(&mut schema, LayoutMode::Packed).expect("compile");
-        // channel_id=0, length=12, big-endian
+        let doc = chunk_header_doc();
+        let engine = AlkTypeEngine::compile(&doc, "ChunkHeader", LayoutMode::Packed).expect("compile");
         let buf = [0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 12u8];
         assert!(engine.validate_bytes(&buf).is_ok(), "valid header should pass");
     }
 
     #[test]
     fn validate_bytes_packed_rejects_short_buffer() {
-        let mut schema = chunk_header_schema();
-        let engine = AlkTypeEngine::compile(&mut schema, LayoutMode::Packed).expect("compile");
-        // Only 4 bytes — the length field can't be read.
+        let doc = chunk_header_doc();
+        let engine = AlkTypeEngine::compile(&doc, "ChunkHeader", LayoutMode::Packed).expect("compile");
         let buf = [0u8; 4];
         let err = engine.validate_bytes(&buf).unwrap_err();
         assert!(matches!(err, AlkTypeError::Access { .. }), "got {err:?}");
@@ -896,17 +958,16 @@ mod tests {
 
     #[test]
     fn validate_bytes_aligned_accepts_valid_chunk_header() {
-        let mut schema = chunk_header_schema();
-        let engine = AlkTypeEngine::compile(&mut schema, LayoutMode::Aligned).expect("compile");
-        // channel_id=42, length=7, big-endian
+        let doc = chunk_header_doc();
+        let engine = AlkTypeEngine::compile(&doc, "ChunkHeader", LayoutMode::Aligned).expect("compile");
         let buf = [0u8, 0u8, 0u8, 42u8, 0u8, 0u8, 0u8, 7u8];
         assert!(engine.validate_bytes(&buf).is_ok(), "valid header should pass");
     }
 
     #[test]
     fn validate_bytes_aligned_rejects_short_buffer() {
-        let mut schema = chunk_header_schema();
-        let engine = AlkTypeEngine::compile(&mut schema, LayoutMode::Aligned).expect("compile");
+        let doc = chunk_header_doc();
+        let engine = AlkTypeEngine::compile(&doc, "ChunkHeader", LayoutMode::Aligned).expect("compile");
         let buf = [0u8; 6];
         let err = engine.validate_bytes(&buf).unwrap_err();
         assert!(
@@ -915,35 +976,21 @@ mod tests {
         );
     }
 
-    #[test]
-    fn validate_bytes_packed_rejects_when_schema_constraint_violated() {
-        // Schema with a maxLength constraint on a string field. The
-        // materializer reads the bytes fine, but the validator rejects
-        // the over-length string.
-        let mut schema = crate::builder::Schema::struct_()
-            .field(
-                "name",
-                crate::builder::Schema::string().max_length(3),
-            )
-            .build();
-        let engine = AlkTypeEngine::compile(&mut schema, LayoutMode::Packed).expect("compile");
-        // length=5 (LE) + "hello" — exceeds maxLength 3
-        let mut buf = vec![0u8; 9];
-        buf[0..4].copy_from_slice(&5u32.to_le_bytes());
-        buf[4..9].copy_from_slice(b"hello");
-        let err = engine.validate_bytes(&buf).unwrap_err();
-        assert!(matches!(err, AlkTypeError::Validation(_)), "got {err:?}");
-    }
-
     #[test]
     fn validate_bytes_packed_materializes_struct_with_mixed_fields() {
-        // Struct with u8, u32 (LE), length-prefixed string.
-        let mut schema = crate::builder::Schema::struct_()
-            .field("flag", crate::builder::Schema::uint8())
-            .field("id", crate::builder::Schema::uint32())
-            .field("name", crate::builder::Schema::string())
-            .build();
-        let engine = AlkTypeEngine::compile(&mut schema, LayoutMode::Packed).expect("compile");
+        let doc = json!({
+            "$defs": {
+                "S": {
+                    "kind": "struct",
+                    "fields": [
+                        { "name": "flag",  "kind": "uint8" },
+                        { "name": "id",    "kind": "uint32" },
+                        { "name": "name",  "kind": "string" }
+                    ]
+                }
+            }
+        });
+        let engine = AlkTypeEngine::compile(&doc, "S", LayoutMode::Packed).expect("compile");
         let mut buf = vec![0u8; 16];
         buf[0] = 0xAB;
         buf[1..5].copy_from_slice(&0x01020304u32.to_le_bytes());
@@ -953,20 +1000,23 @@ mod tests {
     }
 
     #[test]
-    fn validate_bytes_with_builder_schema_round_trips() {
-        // Full round-trip: build schema via builder, compile, write bytes
-        // directly (packed-mode writes go through `LayoutBuilder`; for
-        // this test we write the two u32s directly since the schema is
-        // a simple flat struct), then validate via `validate_bytes`.
-        let mut schema = crate::builder::Schema::struct_()
-            .endian(Endian::Little)
-            .field("channel_id", crate::builder::Schema::uint32())
-            .field("length", crate::builder::Schema::uint32())
-            .build();
-        let engine = AlkTypeEngine::compile(&mut schema, LayoutMode::Packed).expect("compile");
+    fn validate_bytes_with_simple_struct_round_trips() {
+        let doc = json!({
+            "$defs": {
+                "S": {
+                    "kind": "struct",
+                    "endian": "little",
+                    "fields": [
+                        { "name": "channel_id", "kind": "uint32" },
+                        { "name": "length",     "kind": "uint32" }
+                    ]
+                }
+            }
+        });
+        let engine = AlkTypeEngine::compile(&doc, "S", LayoutMode::Packed).expect("compile");
         let mut buf = vec![0u8; 8];
         buf[0..4].copy_from_slice(&42u32.to_le_bytes());
         buf[4..8].copy_from_slice(&7u32.to_le_bytes());
         assert!(engine.validate_bytes(&buf).is_ok());
     }
-}
+}
\ No newline at end of file
diff --git a/src/layout_builder.rs b/src/layout_builder.rs
index 6cabfdf..cda9c7a 100644
--- a/src/layout_builder.rs
+++ b/src/layout_builder.rs
@@ -15,38 +15,36 @@
 //!   known byte size; the offset advances by the size. No alignment
 //!   padding is inserted (the `u32` at offset 1 is unaligned — correct
 //!   for protocol wire formats).
-//! - **Variable-length fields** (`AlkType:String`, `AlkType:Bytes`,
-//!   `AlkType:Timestamp`, `AlkType:Record`): always inline
-//!   length-prefixed in packed mode. The 4-byte length prefix is
-//!   recorded at the current offset; the offset advances by `4 +
-//!   data_size` where `data_size` comes from `var_sizes` keyed by the
-//!   field's dotted path.
-//! - **`AlkType:Struct`**: recurses into `properties`, propagating the
-//!   field path prefix (e.g., `"header.version"`). No padding before,
-//!   between, or after the struct's fields.
-//! - **`AlkType:Array`** of fixed-size elements with a fixed count
-//!   (`minItems == maxItems`): element `i` at
-//!   `array_offset + i × element_size`. Each element is recorded as
+//! - **Variable-length fields** (`string`, `bytes`, `timestamp`,
+//!   `record`): always inline length-prefixed in packed mode. The
+//!   4-byte length prefix is recorded at the current offset; the offset
+//!   advances by `4 + data_size` where `data_size` comes from `var_sizes`
+//!   keyed by the field's dotted path.
+//! - **`struct`**: recurses into `fields`, propagating the field path
+//!   prefix (e.g., `"header.version"`). No padding before, between, or
+//!   after the struct's fields.
+//! - **`array`** (fixed-size elements with a known count): element `i`
+//!   at `array_offset + i × element_size`. Each element is recorded as
 //!   `"<array_path>[i]"`.
-//! - **`AlkType:Array`** with a variable count: a 4-byte count prefix
-//!   at the array's offset. The consumer provides the total element
-//!   data size in `var_sizes` under the array's field path; the builder
-//!   adds `4 + data_size`.
-//! - **`AlkType:Union`** with a byte-offset discriminator: the
-//!   discriminator is recorded at `"<union_path>.__discriminator"`.
-//!   The consumer provides the discriminator value as a `usize` in
-//!   `var_sizes` under `"<union_path>.__discriminator"`. The variant
-//!   struct is laid out starting at `union_offset + disc_offset +
-//!   disc_size`, with field paths prefixed by the union's path.
-//! - **`AlkType:Union`** with a field-name discriminator: the consumer
-//!   provides the 0-based variant index in `var_sizes` under
+//! - **`union`** with a byte-offset discriminator: the discriminator is
+//!   recorded at `"<union_path>.__discriminator"`. The consumer provides
+//!   the discriminator value as a `usize` in `var_sizes` under
+//!   `"<union_path>.__discriminator"`. The variant struct is laid out
+//!   starting at `union_offset + disc_offset + disc_size`, with field
+//!   paths prefixed by the union's path.
+//! - **`union`** with a field-name discriminator: the consumer provides
+//!   the 0-based variant index in `var_sizes` under
 //!   `"<union_path>.__variant"`. The selected variant struct is laid
 //!   out at the union's offset, with field paths prefixed by the
 //!   union's path. The discriminator field is a regular field within
 //!   the variant struct.
 
+use crate::bast::{
+    BastArray, BastDefKind, BastDiscriminator, BastDoc, BastField, BastStruct, BastType,
+    BastUnion,
+};
 use crate::error::AlkTypeError;
-use crate::schema::{self, get_alktype_kind_loose_enum, resolve_ref_or_inline, DiscriminatorKind, Endian, AlkTypeKind, DISCRIMINATOR_PATH, U32_SIZE};
+use crate::schema::{AlkTypeKind, Endian, DISCRIMINATOR_PATH, U32_SIZE};
 use serde_json::Value;
 use std::collections::HashMap;
 
@@ -68,8 +66,8 @@ pub struct FieldPosition {
 /// and the total buffer size needed.
 ///
 /// Construct via [`LayoutBuilder::build`]. Fields are stored in layout
-/// order (the order they appear in the schema's `properties`, with
-/// nested struct fields appearing inline).
+/// order (the order they appear in the BAST `fields` array, with nested
+/// struct fields appearing inline).
 #[derive(Debug)]
 pub struct PackedLayout {
     fields: Vec<(String, FieldPosition)>,
@@ -96,9 +94,8 @@ impl PackedLayout {
 
     /// Iterate over all `(field_path, position)` pairs in layout order.
     ///
-    /// Field order matches the schema's `properties` order (preserved by
-    /// `serde_json`'s `preserve_order` feature). Nested struct fields
-    /// appear after their parent's path prefix.
+    /// Field order matches the BAST `fields` array order. Nested struct
+    /// fields appear after their parent's path prefix.
     pub fn iter(&self) -> impl Iterator<Item = &(String, FieldPosition)> {
         self.fields.iter()
     }
@@ -132,34 +129,41 @@ impl PackedLayout {
 /// this is correct for protocol wire formats, which pack fields tightly.
 #[derive(Debug)]
 pub struct LayoutBuilder {
-    schema: Value,
+    doc_value: Value,
+    root_name: String,
     endian: Endian,
 }
 
 impl LayoutBuilder {
-    /// Create a new LayoutBuilder from a schema.
+    /// Create a new LayoutBuilder from a BAST document.
     ///
-    /// The top-level schema must declare `AlkType:Struct`. Endianness is
-    /// parsed via [`Endian::from_schema`] (defaults to little-endian).
+    /// The root type must be a struct. Endianness is read from the
+    /// root struct's `endian` annotation (defaults to little-endian).
+    ///
+    /// The builder retains the raw BAST `Value` and re-parses the typed
+    /// tree on each [`build`](Self::build) call; this is cheap (the
+    /// typed tree borrows from the source without cloning field data).
     ///
     /// # Errors
     ///
-    /// Returns [`AlkTypeError::Schema`] if the schema has no
-    /// `AlkType:*` kind or the top-level kind is not `AlkType:Struct`.
-    pub fn new(schema: &Value) -> Result<Self, AlkTypeError> {
-        let kind = schema::get_alktype_kind(schema)
-            .and_then(|s| s.parse::<AlkTypeKind>().ok())
-            .ok_or_else(|| {
-                AlkTypeError::Schema("top-level schema has no AlkType:* kind".to_string())
-            })?;
-        if kind != AlkTypeKind::Struct {
-            return Err(AlkTypeError::Schema(format!(
-                "LayoutBuilder requires a AlkType:Struct at the top level, got {kind}"
-            )));
-        }
-        let endian = Endian::from_schema(schema);
+    /// Returns [`AlkTypeError::Schema`] if the document is malformed or
+    /// the root type is not a struct.
+    pub fn new(bast_doc: &Value, root_name: &str) -> Result<Self, AlkTypeError> {
+        let doc = BastDoc::new(bast_doc, root_name)?;
+        let root_def = doc.root_def();
+        let struct_node = match root_def.kind() {
+            BastDefKind::Struct(s) => s,
+            other => {
+                return Err(AlkTypeError::Schema(format!(
+                    "LayoutBuilder requires a struct at the root, got {kind}",
+                    kind = other.alk_kind()
+                )));
+            }
+        };
+        let endian = struct_node.endian();
         Ok(Self {
-            schema: schema.clone(),
+            doc_value: bast_doc.clone(),
+            root_name: root_name.to_string(),
             endian,
         })
     }
@@ -178,68 +182,62 @@ impl LayoutBuilder {
     /// # Errors
     ///
     /// - [`AlkTypeError::Schema`] for malformed schemas (missing
-    ///   `properties`, unknown kind, unresolvable `$ref`).
+    ///   `fields`, unknown kind, unresolvable `$ref`).
     /// - [`AlkTypeError::Offset`] for missing variable-length field
     ///   sizes in `var_sizes`, missing discriminator values, or unknown
     ///   discriminator values.
     pub fn build(&self, var_sizes: &HashMap<String, usize>) -> Result<PackedLayout, AlkTypeError> {
+        let doc = BastDoc::new(&self.doc_value, &self.root_name)?;
+        let root_def = doc.root_def();
+        let struct_node = match root_def.kind() {
+            BastDefKind::Struct(s) => s,
+            _ => unreachable!("checked in new; doc_value is immutable"),
+        };
         let mut ctx = BuildCtx {
-            root: &self.schema,
+            doc: &doc,
             var_sizes,
             fields: Vec::new(),
         };
         let mut offset: usize = 0;
-        ctx.walk_struct(&self.schema, "", &mut offset)?;
+        ctx.walk_struct(struct_node, "", &mut offset)?;
         Ok(PackedLayout {
             fields: ctx.fields,
             total_size: offset,
         })
     }
 
-    /// The endianness parsed from the schema.
+    /// The endianness parsed from the root struct.
     pub fn endian(&self) -> Endian {
         self.endian
     }
 }
 
 /// Mutable context threaded through the recursive layout computation.
-struct BuildCtx<'a> {
-    root: &'a Value,
-    var_sizes: &'a HashMap<String, usize>,
+struct BuildCtx<'d> {
+    doc: &'d BastDoc<'d>,
+    var_sizes: &'d HashMap<String, usize>,
     fields: Vec<(String, FieldPosition)>,
 }
 
-impl<'a> BuildCtx<'a> {
-    /// Recurse into a `AlkType:Struct`, appending `(field_path, FieldPosition)`
+impl<'d> BuildCtx<'d> {
+    /// Recurse into a `BastStruct`, appending `(field_path, FieldPosition)`
     /// pairs to `self.fields` and advancing `offset`.
     ///
     /// `prefix` is the dotted path prefix for nested fields (empty at the
     /// top level).
     fn walk_struct(
         &mut self,
-        schema: &Value,
+        struct_node: &BastStruct<'d>,
         prefix: &str,
         offset: &mut usize,
     ) -> Result<(), AlkTypeError> {
-        let properties = schema
-            .as_object()
-            .and_then(|o| o.get("properties"))
-            .and_then(Value::as_object)
-            .ok_or_else(|| {
-                AlkTypeError::Schema("struct schema has no 'properties' object".to_string())
-            })?;
-
-        let field_schemas: Vec<(String, Value)> = properties
-            .iter()
-            .map(|(k, v)| (k.clone(), v.clone()))
-            .collect();
-        for (name, field_schema) in field_schemas {
+        for field in struct_node.fields() {
             let field_path = if prefix.is_empty() {
-                name
+                field.name().to_string()
             } else {
-                format!("{prefix}.{name}")
+                format!("{prefix}.{}", field.name())
             };
-            self.walk_field(&field_schema, &field_path, offset)?;
+            self.walk_field(field, &field_path, offset)?;
         }
         Ok(())
     }
@@ -248,47 +246,50 @@ impl<'a> BuildCtx<'a> {
     /// appending any field paths to `self.fields`.
     fn walk_field(
         &mut self,
-        field_schema: &Value,
+        field: &BastField<'d>,
         field_path: &str,
         offset: &mut usize,
     ) -> Result<(), AlkTypeError> {
-        let kind = get_alktype_kind_loose_enum(field_schema).ok_or_else(|| AlkTypeError::Offset {
-            field_path: field_path.to_string(),
-            reason: "field schema has no AlkType:* kind".to_string(),
-        })?;
-
-        match kind {
-            AlkTypeKind::Struct => self.walk_struct(field_schema, field_path, offset),
-            AlkTypeKind::Union => self.walk_union(field_schema, field_path, offset),
-            AlkTypeKind::Array => self.walk_array(field_schema, field_path, offset),
-            AlkTypeKind::String
-            | AlkTypeKind::Bytes
-            | AlkTypeKind::Timestamp
-            | AlkTypeKind::Record => {
-                self.walk_variable(field_path, offset, kind)
+        let ty = field.ty();
+        let resolved = self.doc.resolve_typeref(ty)?;
+        match &resolved {
+            BastType::Struct(s) => self.walk_struct(s, field_path, offset),
+            BastType::Union(u) => self.walk_union(u, field_path, offset),
+            BastType::Array(a) => self.walk_array(a, field_path, offset),
+            BastType::Record(_) => self.walk_variable(field_path, offset, resolved.alk_kind()),
+            BastType::Primitive(k) if k.is_variable_length() => {
+                self.walk_variable(field_path, offset, *k)
             }
-            k if k.is_fixed_size() => {
-                let size = k.type_size().ok_or_else(|| AlkTypeError::Offset {
-                    field_path: field_path.to_string(),
-                    reason: format!("type_size returned None for fixed kind {k}"),
-                })?;
-                let start = *offset;
-                *offset = start
-                    .checked_add(size)
-                    .ok_or_else(|| AlkTypeError::Offset {
-                        field_path: field_path.to_string(),
-                        reason: format!("offset {start} + size {size} overflows usize"),
-                    })?;
-                self.push(field_path, start, size, k);
-                Ok(())
-            }
-            other => Err(AlkTypeError::Offset {
+            BastType::Primitive(k) => self.walk_fixed(*k, field_path, offset),
+            BastType::Enum(_) => self.walk_fixed(AlkTypeKind::Enum, field_path, offset),
+            BastType::Ref(_) => Err(AlkTypeError::Offset {
                 field_path: field_path.to_string(),
-                reason: format!("unsupported AlkType kind {other} for packed layout computation"),
+                reason: "internal: resolve_typeref returned a Ref".to_string(),
             }),
         }
     }
 
+    fn walk_fixed(
+        &mut self,
+        kind: AlkTypeKind,
+        field_path: &str,
+        offset: &mut usize,
+    ) -> Result<(), AlkTypeError> {
+        let size = kind.type_size().ok_or_else(|| AlkTypeError::Offset {
+            field_path: field_path.to_string(),
+            reason: format!("type_size returned None for fixed kind {kind}"),
+        })?;
+        let start = *offset;
+        *offset = start
+            .checked_add(size)
+            .ok_or_else(|| AlkTypeError::Offset {
+                field_path: field_path.to_string(),
+                reason: format!("offset {start} + size {size} overflows usize"),
+            })?;
+        self.push(field_path, start, size, kind);
+        Ok(())
+    }
+
     /// Compute the layout for a variable-length field (String/Bytes/
     /// Timestamp/Record). Always inline length-prefixed in packed mode.
     fn walk_variable(
@@ -322,39 +323,26 @@ impl<'a> BuildCtx<'a> {
         Ok(())
     }
 
-    /// Compute the layout for a `AlkType:Array` field.
+    /// Compute the layout for a `BastArray` field.
+    ///
+    /// BAST arrays always have a `count` (D-BAST-004). Fixed-size elements
+    /// are laid out with a known stride; variable-length elements are not
+    /// supported in v1.
     fn walk_array(
         &mut self,
-        field_schema: &Value,
+        array: &BastArray<'d>,
         field_path: &str,
         offset: &mut usize,
     ) -> Result<(), AlkTypeError> {
-        let obj = field_schema
-            .as_object()
-            .ok_or_else(|| AlkTypeError::Offset {
-                field_path: field_path.to_string(),
-                reason: "array schema is not an object".to_string(),
-            })?;
-
-        let items = obj.get("items").ok_or_else(|| AlkTypeError::Offset {
-            field_path: field_path.to_string(),
-            reason: "TArray is missing 'items'".to_string(),
-        })?;
-        let element_schema =
-            resolve_ref_or_inline(items, self.root).ok_or_else(|| AlkTypeError::Offset {
-                field_path: field_path.to_string(),
-                reason: "could not resolve TArray items schema".to_string(),
-            })?;
-        let elem_kind = get_alktype_kind_loose_enum(element_schema).ok_or_else(|| AlkTypeError::Offset {
-            field_path: field_path.to_string(),
-            reason: "TArray element schema has no AlkType:* kind".to_string(),
-        })?;
+        let element_ty = array.element();
+        let resolved_elem = self.doc.resolve_typeref(element_ty)?;
+        let elem_kind = resolved_elem.alk_kind();
 
         if !elem_kind.is_fixed_size() {
             return Err(AlkTypeError::Offset {
                 field_path: field_path.to_string(),
                 reason: format!(
-                    "TArray of variable-length element kind {elem_kind} is not supported (OQ-069)"
+                    "array of variable-length element kind {elem_kind} is not supported (OQ-001)"
                 ),
             });
         }
@@ -363,111 +351,59 @@ impl<'a> BuildCtx<'a> {
             field_path: field_path.to_string(),
             reason: format!("element kind {elem_kind} has no fixed size"),
         })?;
+        let count = array.count();
 
-        let min_items = obj
-            .get("minItems")
-            .and_then(Value::as_u64)
-            .map(|n| n as usize);
-        let max_items = obj
-            .get("maxItems")
-            .and_then(Value::as_u64)
-            .map(|n| n as usize);
-        let fixed_count = match (min_items, max_items) {
-            (Some(mn), Some(mx)) if mn == mx => Some(mn),
-            _ => None,
-        };
-
-        if let Some(count) = fixed_count {
-            let start = *offset;
-            for i in 0..count {
-                let elem_offset = start
-                    .checked_add(
-                        i.checked_mul(elem_size)
-                            .ok_or_else(|| AlkTypeError::Offset {
-                                field_path: field_path.to_string(),
-                                reason: format!(
-                                    "element index {i} × size {elem_size} overflows usize"
-                                ),
-                            })?,
-                    )
-                    .ok_or_else(|| AlkTypeError::Offset {
-                        field_path: field_path.to_string(),
-                        reason: format!("element offset {start} + {i}×{elem_size} overflows usize"),
-                    })?;
-                self.push(
-                    &format!("{field_path}[{i}]"),
-                    elem_offset,
-                    elem_size,
-                    elem_kind,
-                );
-            }
-            let array_size = count
-                .checked_mul(elem_size)
+        let start = *offset;
+        for i in 0..count {
+            let elem_offset = start
+                .checked_add(
+                    i.checked_mul(elem_size)
+                        .ok_or_else(|| AlkTypeError::Offset {
+                            field_path: field_path.to_string(),
+                            reason: format!(
+                                "element index {i} × size {elem_size} overflows usize"
+                            ),
+                        })?,
+                )
                 .ok_or_else(|| AlkTypeError::Offset {
                     field_path: field_path.to_string(),
-                    reason: format!("array size {count} × {elem_size} overflows usize"),
+                    reason: format!("element offset {start} + {i}×{elem_size} overflows usize"),
                 })?;
-            *offset = start
-                .checked_add(array_size)
-                .ok_or_else(|| AlkTypeError::Offset {
-                    field_path: field_path.to_string(),
-                    reason: format!("offset {start} + array size {array_size} overflows usize"),
-                })?;
-            Ok(())
-        } else {
-            let data_size =
-                self.var_sizes
-                    .get(field_path)
-                    .copied()
-                    .ok_or_else(|| AlkTypeError::Offset {
-                        field_path: field_path.to_string(),
-                        reason: "missing variable-count array element data size".to_string(),
-                    })?;
-            let start = *offset;
-            let total = U32_SIZE
-                .checked_add(data_size)
-                .ok_or_else(|| AlkTypeError::Offset {
-                    field_path: field_path.to_string(),
-                    reason: format!(
-                        "count prefix {U32_SIZE} + data size {data_size} overflows usize"
-                    ),
-                })?;
-            *offset = start
-                .checked_add(total)
-                .ok_or_else(|| AlkTypeError::Offset {
-                    field_path: field_path.to_string(),
-                    reason: format!("offset {start} + total {total} overflows usize"),
-                })?;
-            self.push(field_path, start, U32_SIZE, AlkTypeKind::Array);
-            Ok(())
+            self.push(
+                &format!("{field_path}[{i}]"),
+                elem_offset,
+                elem_size,
+                elem_kind,
+            );
         }
+        let array_size = count
+            .checked_mul(elem_size)
+            .ok_or_else(|| AlkTypeError::Offset {
+                field_path: field_path.to_string(),
+                reason: format!("array size {count} × {elem_size} overflows usize"),
+            })?;
+        *offset = start
+            .checked_add(array_size)
+            .ok_or_else(|| AlkTypeError::Offset {
+                field_path: field_path.to_string(),
+                reason: format!("offset {start} + array size {array_size} overflows usize"),
+            })?;
+        Ok(())
     }
 
-    /// Compute the layout for a `AlkType:Union` field.
+    /// Compute the layout for a `BastUnion` field.
     fn walk_union(
         &mut self,
-        field_schema: &Value,
+        union_node: &BastUnion<'d>,
         field_path: &str,
         offset: &mut usize,
     ) -> Result<(), AlkTypeError> {
-        let disc = schema::parse_discriminator(field_schema)?;
-        let mapping = field_schema
-            .as_object()
-            .and_then(|o| o.get("mapping"))
-            .and_then(Value::as_object)
-            .ok_or_else(|| AlkTypeError::Offset {
-                field_path: field_path.to_string(),
-                reason: "TUnion is missing 'mapping' object".to_string(),
-            })?;
-
+        let disc = union_node.discriminator();
         match disc {
-            DiscriminatorKind::Byte {
-                offset: disc_off,
-                disc_type,
-            } => self
-                .walk_byte_discriminator_union(field_path, offset, disc_type, disc_off, mapping),
-            DiscriminatorKind::Field { name: _ } => {
-                self.walk_field_discriminator_union(field_path, offset, mapping)
+            BastDiscriminator::Byte { offset: disc_off, disc_type } => self
+                .walk_byte_discriminator_union(field_path, offset, *disc_type, *disc_off, union_node),
+            BastDiscriminator::Field { name: _ } => {
+                self.walk_field_discriminator_union(field_path, offset, union_node)
             }
         }
     }
@@ -479,7 +415,7 @@ impl<'a> BuildCtx<'a> {
         offset: &mut usize,
         disc_type: AlkTypeKind,
         disc_off: usize,
-        mapping: &serde_json::Map<String, Value>,
+        union_node: &BastUnion<'d>,
     ) -> Result<(), AlkTypeError> {
         let disc_size = disc_type.type_size().ok_or_else(|| AlkTypeError::Offset {
             field_path: field_path.to_string(),
@@ -509,28 +445,25 @@ impl<'a> BuildCtx<'a> {
         self.push(&disc_key, disc_abs_offset, disc_size, disc_type);
 
         let variant_key = disc_value.to_string();
-        let variant_schema = mapping
-            .get(&variant_key)
-            .ok_or_else(|| AlkTypeError::Offset {
-                field_path: field_path.to_string(),
-                reason: format!("unknown discriminator value: {variant_key}"),
-            })?;
-        let resolved = resolve_ref_or_inline(variant_schema, self.root).ok_or_else(|| {
+        let variant_ty = union_node.variant_for(&variant_key).ok_or_else(|| {
             AlkTypeError::Offset {
                 field_path: field_path.to_string(),
-                reason: "could not resolve TUnion variant schema ($ref not found)".to_string(),
+                reason: format!("unknown discriminator value: {variant_key}"),
             }
         })?;
-        let v_kind = get_alktype_kind_loose_enum(resolved).ok_or_else(|| AlkTypeError::Offset {
-            field_path: field_path.to_string(),
-            reason: "TUnion variant schema has no AlkType:* kind".to_string(),
-        })?;
-        if v_kind != AlkTypeKind::Struct {
-            return Err(AlkTypeError::Offset {
-                field_path: field_path.to_string(),
-                reason: format!("TUnion variant must be AlkType:Struct, got {v_kind}"),
-            });
-        }
+        let variant_def = self.doc.resolve_typeref_as_def(variant_ty, field_path)?;
+        let variant_struct = match variant_def.kind() {
+            BastDefKind::Struct(s) => s,
+            other => {
+                return Err(AlkTypeError::Offset {
+                    field_path: field_path.to_string(),
+                    reason: format!(
+                        "TUnion variant must be a struct, got {kind}",
+                        kind = other.alk_kind()
+                    ),
+                });
+            }
+        };
 
         let variant_start =
             disc_abs_offset
@@ -542,7 +475,7 @@ impl<'a> BuildCtx<'a> {
                     ),
                 })?;
         *offset = variant_start;
-        self.walk_struct(resolved, field_path, offset)?;
+        self.walk_struct(variant_struct, field_path, offset)?;
         Ok(())
     }
 
@@ -555,7 +488,7 @@ impl<'a> BuildCtx<'a> {
         &mut self,
         field_path: &str,
         offset: &mut usize,
-        mapping: &serde_json::Map<String, Value>,
+        union_node: &BastUnion<'d>,
     ) -> Result<(), AlkTypeError> {
         let variant_key = format!("{field_path}.{VARIANT_KEY}");
         let variant_index =
@@ -566,10 +499,10 @@ impl<'a> BuildCtx<'a> {
                     field_path: field_path.to_string(),
                     reason: format!("missing variant index at key '{variant_key}'"),
                 })?;
+        let mapping = union_node.mapping();
         let variant_entry =
             mapping
-                .iter()
-                .nth(variant_index)
+                .get(variant_index)
                 .ok_or_else(|| AlkTypeError::Offset {
                     field_path: field_path.to_string(),
                     reason: format!(
@@ -577,24 +510,21 @@ impl<'a> BuildCtx<'a> {
                         mapping.len()
                     ),
                 })?;
-        let variant_schema = variant_entry.1;
-        let resolved = resolve_ref_or_inline(variant_schema, self.root).ok_or_else(|| {
-            AlkTypeError::Offset {
-                field_path: field_path.to_string(),
-                reason: "could not resolve TUnion variant schema ($ref not found)".to_string(),
+        let variant_ty = &variant_entry.1;
+        let variant_def = self.doc.resolve_typeref_as_def(variant_ty, field_path)?;
+        let variant_struct = match variant_def.kind() {
+            BastDefKind::Struct(s) => s,
+            other => {
+                return Err(AlkTypeError::Offset {
+                    field_path: field_path.to_string(),
+                    reason: format!(
+                        "TUnion variant must be a struct, got {kind}",
+                        kind = other.alk_kind()
+                    ),
+                });
             }
-        })?;
-        let v_kind = get_alktype_kind_loose_enum(resolved).ok_or_else(|| AlkTypeError::Offset {
-            field_path: field_path.to_string(),
-            reason: "TUnion variant schema has no AlkType:* kind".to_string(),
-        })?;
-        if v_kind != AlkTypeKind::Struct {
-            return Err(AlkTypeError::Offset {
-                field_path: field_path.to_string(),
-                reason: format!("TUnion variant must be AlkType:Struct, got {v_kind}"),
-            });
-        }
-        self.walk_struct(resolved, field_path, offset)?;
+        };
+        self.walk_struct(variant_struct, field_path, offset)?;
         Ok(())
     }
 
@@ -616,8 +546,12 @@ mod tests {
     use super::*;
     use serde_json::json;
 
-    fn build(schema: &Value, var_sizes: &HashMap<String, usize>) -> PackedLayout {
-        LayoutBuilder::new(schema)
+    fn build(
+        root: &Value,
+        root_name: &str,
+        var_sizes: &HashMap<String, usize>,
+    ) -> PackedLayout {
+        LayoutBuilder::new(root, root_name)
             .expect("builder")
             .build(var_sizes)
             .expect("layout")
@@ -629,15 +563,19 @@ mod tests {
 
     #[test]
     fn fixed_fields_packed_no_alignment_padding() {
-        let schema = json!({
-            "AlkType:Struct": true,
-            "properties": {
-                "a": { "AlkType:Uint8": true },
-                "b": { "AlkType:Uint32": true },
-                "c": { "AlkType:Uint16": true }
+        let root = json!({
+            "$defs": {
+                "S": {
+                    "kind": "struct",
+                    "fields": [
+                        { "name": "a", "kind": "uint8" },
+                        { "name": "b", "kind": "uint32" },
+                        { "name": "c", "kind": "uint16" }
+                    ]
+                }
             }
         });
-        let layout = build(&schema, &var_sizes(&[]));
+        let layout = build(&root, "S", &var_sizes(&[]));
         assert_eq!(
             layout.get("a"),
             Some(&FieldPosition {
@@ -667,15 +605,19 @@ mod tests {
 
     #[test]
     fn spec_example_u8_u32_string_total_19() {
-        let schema = json!({
-            "AlkType:Struct": true,
-            "properties": {
-                "flag": { "AlkType:Uint8": true },
-                "id": { "AlkType:Uint32": true },
-                "payload": { "AlkType:String": true }
+        let root = json!({
+            "$defs": {
+                "S": {
+                    "kind": "struct",
+                    "fields": [
+                        { "name": "flag",    "kind": "uint8" },
+                        { "name": "id",      "kind": "uint32" },
+                        { "name": "payload", "kind": "string" }
+                    ]
+                }
             }
         });
-        let layout = build(&schema, &var_sizes(&[("payload", 10)]));
+        let layout = build(&root, "S", &var_sizes(&[("payload", 10)]));
         assert_eq!(
             layout.get("flag"),
             Some(&FieldPosition {
@@ -705,14 +647,18 @@ mod tests {
 
     #[test]
     fn variable_length_field_shifts_subsequent_fields() {
-        let schema = json!({
-            "AlkType:Struct": true,
-            "properties": {
-                "name": { "AlkType:String": true },
-                "tail": { "AlkType:Uint8": true }
+        let root = json!({
+            "$defs": {
+                "S": {
+                    "kind": "struct",
+                    "fields": [
+                        { "name": "name", "kind": "string" },
+                        { "name": "tail", "kind": "uint8" }
+                    ]
+                }
             }
         });
-        let layout = build(&schema, &var_sizes(&[("name", 5)]));
+        let layout = build(&root, "S", &var_sizes(&[("name", 5)]));
         assert_eq!(
             layout.get("name"),
             Some(&FieldPosition {
@@ -734,13 +680,17 @@ mod tests {
 
     #[test]
     fn bytes_field_uses_var_sizes() {
-        let schema = json!({
-            "AlkType:Struct": true,
-            "properties": {
-                "blob": { "AlkType:Bytes": true }
+        let root = json!({
+            "$defs": {
+                "S": {
+                    "kind": "struct",
+                    "fields": [
+                        { "name": "blob", "kind": "bytes" }
+                    ]
+                }
             }
         });
-        let layout = build(&schema, &var_sizes(&[("blob", 3)]));
+        let layout = build(&root, "S", &var_sizes(&[("blob", 3)]));
         assert_eq!(
             layout.get("blob"),
             Some(&FieldPosition {
@@ -754,13 +704,17 @@ mod tests {
 
     #[test]
     fn timestamp_field_uses_var_sizes() {
-        let schema = json!({
-            "AlkType:Struct": true,
-            "properties": {
-                "ts": { "AlkType:Timestamp": true }
+        let root = json!({
+            "$defs": {
+                "S": {
+                    "kind": "struct",
+                    "fields": [
+                        { "name": "ts", "kind": "timestamp" }
+                    ]
+                }
             }
         });
-        let layout = build(&schema, &var_sizes(&[("ts", 20)]));
+        let layout = build(&root, "S", &var_sizes(&[("ts", 20)]));
         assert_eq!(
             layout.get("ts"),
             Some(&FieldPosition {
@@ -774,16 +728,20 @@ mod tests {
 
     #[test]
     fn record_field_uses_var_sizes() {
-        let schema = json!({
-            "AlkType:Struct": true,
-            "properties": {
-                "counts": {
-                    "AlkType:Record": true,
-                    "values": { "AlkType:Uint32": true }
+        let root = json!({
+            "$defs": {
+                "S": {
+                    "kind": "struct",
+                    "fields": [
+                        {
+                            "name": "counts",
+                            "kind": { "kind": "record", "values": "uint32" }
+                        }
+                    ]
                 }
             }
         });
-        let layout = build(&schema, &var_sizes(&[("counts", 100)]));
+        let layout = build(&root, "S", &var_sizes(&[("counts", 100)]));
         assert_eq!(
             layout.get("counts"),
             Some(&FieldPosition {
@@ -797,13 +755,17 @@ mod tests {
 
     #[test]
     fn missing_var_size_returns_offset_error() {
-        let schema = json!({
-            "AlkType:Struct": true,
-            "properties": {
-                "name": { "AlkType:String": true }
+        let root = json!({
+            "$defs": {
+                "S": {
+                    "kind": "struct",
+                    "fields": [
+                        { "name": "name", "kind": "string" }
+                    ]
+                }
             }
         });
-        let builder = LayoutBuilder::new(&schema).expect("builder");
+        let builder = LayoutBuilder::new(&root, "S").expect("builder");
         let err = builder.build(&var_sizes(&[])).unwrap_err();
         match err {
             AlkTypeError::Offset { field_path, reason } => {
@@ -819,20 +781,27 @@ mod tests {
 
     #[test]
     fn nested_struct_dotted_paths() {
-        let schema = json!({
-            "AlkType:Struct": true,
-            "properties": {
-                "header": {
-                    "AlkType:Struct": true,
-                    "properties": {
-                        "magic": { "AlkType:Uint32": true },
-                        "version": { "AlkType:Uint8": true }
-                    }
-                },
-                "body": { "AlkType:Uint32": true }
+        let root = json!({
+            "$defs": {
+                "S": {
+                    "kind": "struct",
+                    "fields": [
+                        {
+                            "name": "header",
+                            "kind": {
+                                "kind": "struct",
+                                "fields": [
+                                    { "name": "magic",   "kind": "uint32" },
+                                    { "name": "version", "kind": "uint8" }
+                                ]
+                            }
+                        },
+                        { "name": "body", "kind": "uint32" }
+                    ]
+                }
             }
         });
-        let layout = build(&schema, &var_sizes(&[]));
+        let layout = build(&root, "S", &var_sizes(&[]));
         assert_eq!(
             layout.get("header.magic"),
             Some(&FieldPosition {
@@ -862,20 +831,27 @@ mod tests {
 
     #[test]
     fn nested_struct_with_variable_field() {
-        let schema = json!({
-            "AlkType:Struct": true,
-            "properties": {
-                "header": {
-                    "AlkType:Struct": true,
-                    "properties": {
-                        "id": { "AlkType:Uint8": true },
-                        "name": { "AlkType:String": true }
-                    }
-                },
-                "tail": { "AlkType:Uint8": true }
+        let root = json!({
+            "$defs": {
+                "S": {
+                    "kind": "struct",
+                    "fields": [
+                        {
+                            "name": "header",
+                            "kind": {
+                                "kind": "struct",
+                                "fields": [
+                                    { "name": "id",   "kind": "uint8" },
+                                    { "name": "name", "kind": "string" }
+                                ]
+                            }
+                        },
+                        { "name": "tail", "kind": "uint8" }
+                    ]
+                }
             }
         });
-        let layout = build(&schema, &var_sizes(&[("header.name", 3)]));
+        let layout = build(&root, "S", &var_sizes(&[("header.name", 3)]));
         assert_eq!(
             layout.get("header.id"),
             Some(&FieldPosition {
@@ -905,18 +881,20 @@ mod tests {
 
     #[test]
     fn array_fixed_count_element_offsets() {
-        let schema = json!({
-            "AlkType:Struct": true,
-            "properties": {
-                "vals": {
-                    "AlkType:Array": true,
-                    "items": { "AlkType:Uint32": true },
-                    "minItems": 3,
-                    "maxItems": 3
+        let root = json!({
+            "$defs": {
+                "S": {
+                    "kind": "struct",
+                    "fields": [
+                        {
+                            "name": "vals",
+                            "kind": { "kind": "array", "element": "uint32", "count": 3 }
+                        }
+                    ]
                 }
             }
         });
-        let layout = build(&schema, &var_sizes(&[]));
+        let layout = build(&root, "S", &var_sizes(&[]));
         assert_eq!(
             layout.get("vals[0]"),
             Some(&FieldPosition {
@@ -946,19 +924,21 @@ mod tests {
 
     #[test]
     fn array_fixed_count_after_preceding_field() {
-        let schema = json!({
-            "AlkType:Struct": true,
-            "properties": {
-                "id": { "AlkType:Uint8": true },
-                "vals": {
-                    "AlkType:Array": true,
-                    "items": { "AlkType:Uint16": true },
-                    "minItems": 2,
-                    "maxItems": 2
+        let root = json!({
+            "$defs": {
+                "S": {
+                    "kind": "struct",
+                    "fields": [
+                        { "name": "id", "kind": "uint8" },
+                        {
+                            "name": "vals",
+                            "kind": { "kind": "array", "element": "uint16", "count": 2 }
+                        }
+                    ]
                 }
             }
         });
-        let layout = build(&schema, &var_sizes(&[]));
+        let layout = build(&root, "S", &var_sizes(&[]));
         assert_eq!(
             layout.get("id"),
             Some(&FieldPosition {
@@ -986,61 +966,26 @@ mod tests {
         assert_eq!(layout.total_size(), 5);
     }
 
-    #[test]
-    fn array_variable_count_uses_count_prefix() {
-        let schema = json!({
-            "AlkType:Struct": true,
-            "properties": {
-                "vals": {
-                    "AlkType:Array": true,
-                    "items": { "AlkType:Uint32": true }
-                }
-            }
-        });
-        let layout = build(&schema, &var_sizes(&[("vals", 12)]));
-        assert_eq!(
-            layout.get("vals"),
-            Some(&FieldPosition {
-                offset: 0,
-                size: 4,
-                kind: AlkTypeKind::Array
-            })
-        );
-        assert_eq!(layout.total_size(), 16);
-    }
-
-    #[test]
-    fn array_variable_count_missing_size_is_offset_error() {
-        let schema = json!({
-            "AlkType:Struct": true,
-            "properties": {
-                "vals": {
-                    "AlkType:Array": true,
-                    "items": { "AlkType:Uint32": true }
-                }
-            }
-        });
-        let builder = LayoutBuilder::new(&schema).expect("builder");
-        let err = builder.build(&var_sizes(&[])).unwrap_err();
-        assert!(matches!(err, AlkTypeError::Offset { .. }));
-    }
-
     #[test]
     fn array_variable_length_element_is_not_supported() {
-        let schema = json!({
-            "AlkType:Struct": true,
-            "properties": {
-                "items": {
-                    "AlkType:Array": true,
-                    "items": { "AlkType:String": true }
+        let root = json!({
+            "$defs": {
+                "S": {
+                    "kind": "struct",
+                    "fields": [
+                        {
+                            "name": "items",
+                            "kind": { "kind": "array", "element": "string", "count": 2 }
+                        }
+                    ]
                 }
             }
         });
-        let builder = LayoutBuilder::new(&schema).expect("builder");
+        let builder = LayoutBuilder::new(&root, "S").expect("builder");
         let err = builder.build(&var_sizes(&[("items", 10)])).unwrap_err();
         match err {
             AlkTypeError::Offset { reason, .. } => {
-                assert!(reason.contains("OQ-069"), "reason: {reason}");
+                assert!(reason.contains("OQ-001"), "reason: {reason}");
             }
             other => panic!("expected Offset, got {other:?}"),
         }
@@ -1048,42 +993,44 @@ mod tests {
 
     #[test]
     fn union_byte_discriminator_sftp_pattern() {
-        let schema = json!({
-            "AlkType:Struct": true,
-            "properties": {
-                "payload": {
-                    "AlkType:Union": true,
-                    "discriminator": {
-                        "kind": "byte",
-                        "offset": 0,
-                        "type": "AlkType:Uint8"
-                    },
+        let root = json!({
+            "$defs": {
+                "S": {
+                    "kind": "struct",
+                    "fields": [
+                        {
+                            "name": "payload",
+                            "kind": { "$ref": "#/$defs/Packet" }
+                        }
+                    ]
+                },
+                "Packet": {
+                    "kind": "union",
+                    "discriminator": { "kind": "byte", "offset": 0, "type": "uint8" },
                     "mapping": {
                         "5": { "$ref": "#/$defs/Read" },
                         "6": { "$ref": "#/$defs/Write" }
                     }
-                }
-            },
-            "$defs": {
+                },
                 "Read": {
-                    "AlkType:Struct": true,
-                    "properties": {
-                        "handle": { "AlkType:Uint32": true },
-                        "length": { "AlkType:Uint32": true }
-                    }
+                    "kind": "struct",
+                    "fields": [
+                        { "name": "handle", "kind": "uint32" },
+                        { "name": "length", "kind": "uint32" }
+                    ]
                 },
                 "Write": {
-                    "AlkType:Struct": true,
-                    "properties": {
-                        "handle": { "AlkType:Uint32": true },
-                        "length": { "AlkType:Uint32": true },
-                        "data": { "AlkType:Uint32": true }
-                    }
+                    "kind": "struct",
+                    "fields": [
+                        { "name": "handle", "kind": "uint32" },
+                        { "name": "length", "kind": "uint32" },
+                        { "name": "data",   "kind": "uint32" }
+                    ]
                 }
             }
         });
         let vs = var_sizes(&[("payload.__discriminator", 5)]);
-        let layout = build(&schema, &vs);
+        let layout = build(&root, "S", &vs);
         assert_eq!(
             layout.get("payload.__discriminator"),
             Some(&FieldPosition {
@@ -1113,42 +1060,44 @@ mod tests {
 
     #[test]
     fn union_byte_discriminator_write_variant() {
-        let schema = json!({
-            "AlkType:Struct": true,
-            "properties": {
-                "payload": {
-                    "AlkType:Union": true,
-                    "discriminator": {
-                        "kind": "byte",
-                        "offset": 0,
-                        "type": "AlkType:Uint8"
-                    },
+        let root = json!({
+            "$defs": {
+                "S": {
+                    "kind": "struct",
+                    "fields": [
+                        {
+                            "name": "payload",
+                            "kind": { "$ref": "#/$defs/Packet" }
+                        }
+                    ]
+                },
+                "Packet": {
+                    "kind": "union",
+                    "discriminator": { "kind": "byte", "offset": 0, "type": "uint8" },
                     "mapping": {
                         "5": { "$ref": "#/$defs/Read" },
                         "6": { "$ref": "#/$defs/Write" }
                     }
-                }
-            },
-            "$defs": {
+                },
                 "Read": {
-                    "AlkType:Struct": true,
-                    "properties": {
-                        "handle": { "AlkType:Uint32": true },
-                        "length": { "AlkType:Uint32": true }
-                    }
+                    "kind": "struct",
+                    "fields": [
+                        { "name": "handle", "kind": "uint32" },
+                        { "name": "length", "kind": "uint32" }
+                    ]
                 },
                 "Write": {
-                    "AlkType:Struct": true,
-                    "properties": {
-                        "handle": { "AlkType:Uint32": true },
-                        "length": { "AlkType:Uint32": true },
-                        "data": { "AlkType:Uint32": true }
-                    }
+                    "kind": "struct",
+                    "fields": [
+                        { "name": "handle", "kind": "uint32" },
+                        { "name": "length", "kind": "uint32" },
+                        { "name": "data",   "kind": "uint32" }
+                    ]
                 }
             }
         });
         let vs = var_sizes(&[("payload.__discriminator", 6)]);
-        let layout = build(&schema, &vs);
+        let layout = build(&root, "S", &vs);
         assert_eq!(
             layout.get("payload.__discriminator"),
             Some(&FieldPosition {
@@ -1170,33 +1119,35 @@ mod tests {
 
     #[test]
     fn union_byte_discriminator_with_variable_variant_field() {
-        let schema = json!({
-            "AlkType:Struct": true,
-            "properties": {
-                "packet": {
-                    "AlkType:Union": true,
-                    "discriminator": {
-                        "kind": "byte",
-                        "offset": 0,
-                        "type": "AlkType:Uint8"
-                    },
+        let root = json!({
+            "$defs": {
+                "S": {
+                    "kind": "struct",
+                    "fields": [
+                        {
+                            "name": "packet",
+                            "kind": { "$ref": "#/$defs/Packet" }
+                        }
+                    ]
+                },
+                "Packet": {
+                    "kind": "union",
+                    "discriminator": { "kind": "byte", "offset": 0, "type": "uint8" },
                     "mapping": {
                         "5": { "$ref": "#/$defs/Read" }
                     }
-                }
-            },
-            "$defs": {
+                },
                 "Read": {
-                    "AlkType:Struct": true,
-                    "properties": {
-                        "handle": { "AlkType:Uint32": true },
-                        "path": { "AlkType:String": true }
-                    }
+                    "kind": "struct",
+                    "fields": [
+                        { "name": "handle", "kind": "uint32" },
+                        { "name": "path",   "kind": "string" }
+                    ]
                 }
             }
         });
         let vs = var_sizes(&[("packet.__discriminator", 5), ("packet.path", 8)]);
-        let layout = build(&schema, &vs);
+        let layout = build(&root, "S", &vs);
         assert_eq!(
             layout.get("packet.__discriminator"),
             Some(&FieldPosition {
@@ -1226,30 +1177,32 @@ mod tests {
 
     #[test]
     fn union_byte_discriminator_unknown_value_is_offset_error() {
-        let schema = json!({
-            "AlkType:Struct": true,
-            "properties": {
-                "payload": {
-                    "AlkType:Union": true,
-                    "discriminator": {
-                        "kind": "byte",
-                        "offset": 0,
-                        "type": "AlkType:Uint8"
-                    },
+        let root = json!({
+            "$defs": {
+                "S": {
+                    "kind": "struct",
+                    "fields": [
+                        {
+                            "name": "payload",
+                            "kind": { "$ref": "#/$defs/Packet" }
+                        }
+                    ]
+                },
+                "Packet": {
+                    "kind": "union",
+                    "discriminator": { "kind": "byte", "offset": 0, "type": "uint8" },
                     "mapping": {
                         "5": { "$ref": "#/$defs/Read" }
                     }
-                }
-            },
-            "$defs": {
+                },
                 "Read": {
-                    "AlkType:Struct": true,
-                    "properties": { "x": { "AlkType:Uint8": true } }
+                    "kind": "struct",
+                    "fields": [ { "name": "x", "kind": "uint8" } ]
                 }
             }
         });
         let vs = var_sizes(&[("payload.__discriminator", 99)]);
-        let builder = LayoutBuilder::new(&schema).expect("builder");
+        let builder = LayoutBuilder::new(&root, "S").expect("builder");
         let err = builder.build(&vs).unwrap_err();
         match err {
             AlkTypeError::Offset { reason, .. } => {
@@ -1261,67 +1214,78 @@ mod tests {
 
     #[test]
     fn union_byte_discriminator_missing_value_is_offset_error() {
-        let schema = json!({
-            "AlkType:Struct": true,
-            "properties": {
-                "payload": {
-                    "AlkType:Union": true,
-                    "discriminator": {
-                        "kind": "byte",
-                        "offset": 0,
-                        "type": "AlkType:Uint8"
-                    },
+        let root = json!({
+            "$defs": {
+                "S": {
+                    "kind": "struct",
+                    "fields": [
+                        {
+                            "name": "payload",
+                            "kind": { "$ref": "#/$defs/Packet" }
+                        }
+                    ]
+                },
+                "Packet": {
+                    "kind": "union",
+                    "discriminator": { "kind": "byte", "offset": 0, "type": "uint8" },
                     "mapping": {
                         "5": { "$ref": "#/$defs/Read" }
                     }
-                }
-            },
-            "$defs": {
+                },
                 "Read": {
-                    "AlkType:Struct": true,
-                    "properties": { "x": { "AlkType:Uint8": true } }
+                    "kind": "struct",
+                    "fields": [ { "name": "x", "kind": "uint8" } ]
                 }
             }
         });
-        let builder = LayoutBuilder::new(&schema).expect("builder");
+        let builder = LayoutBuilder::new(&root, "S").expect("builder");
         let err = builder.build(&var_sizes(&[])).unwrap_err();
         assert!(matches!(err, AlkTypeError::Offset { .. }));
     }
 
     #[test]
     fn union_field_name_discriminator() {
-        let schema = json!({
-            "AlkType:Struct": true,
-            "properties": {
-                "event": {
-                    "AlkType:Union": true,
+        let root = json!({
+            "$defs": {
+                "S": {
+                    "kind": "struct",
+                    "fields": [
+                        {
+                            "name": "event",
+                            "kind": { "$ref": "#/$defs/Event" }
+                        }
+                    ]
+                },
+                "Event": {
+                    "kind": "union",
                     "discriminator": { "kind": "field", "name": "type" },
+                    "fields": [
+                        { "name": "type", "kind": "uint8" }
+                    ],
                     "mapping": {
-                        "read": { "$ref": "#/$defs/Read" },
+                        "read":  { "$ref": "#/$defs/Read" },
                         "write": { "$ref": "#/$defs/Write" }
                     }
-                }
-            },
-            "$defs": {
+                },
                 "Read": {
-                    "AlkType:Struct": true,
-                    "properties": {
-                        "type": { "AlkType:Uint8": true },
-                        "handle": { "AlkType:Uint32": true }
-                    }
+                    "kind": "struct",
+                    "fields": [
+                        { "name": "type",   "kind": "uint8" },
+                        { "name": "handle", "kind": "uint32" }
+                    ]
                 },
                 "Write": {
-                    "AlkType:Struct": true,
-                    "properties": {
-                        "type": { "AlkType:Uint8": true },
-                        "handle": { "AlkType:Uint32": true },
-                        "length": { "AlkType:Uint32": true }
-                    }
+                    "kind": "struct",
+                    "fields": [
+                        { "name": "type",   "kind": "uint8" },
+                        { "name": "handle", "kind": "uint32" },
+                        { "name": "length", "kind": "uint32" }
+                    ]
                 }
             }
         });
         let vs = var_sizes(&[("event.__variant", 0)]);
-        let layout = build(&schema, &vs);
+        let layout = build(&root, "S", &vs);
         assert_eq!(
             layout.get("event.type"),
             Some(&FieldPosition {
@@ -1343,38 +1307,47 @@ mod tests {
 
     #[test]
     fn union_field_name_discriminator_write_variant() {
-        let schema = json!({
-            "AlkType:Struct": true,
-            "properties": {
-                "event": {
-                    "AlkType:Union": true,
+        let root = json!({
+            "$defs": {
+                "S": {
+                    "kind": "struct",
+                    "fields": [
+                        {
+                            "name": "event",
+                            "kind": { "$ref": "#/$defs/Event" }
+                        }
+                    ]
+                },
+                "Event": {
+                    "kind": "union",
                     "discriminator": { "kind": "field", "name": "type" },
+                    "fields": [
+                        { "name": "type", "kind": "uint8" }
+                    ],
                     "mapping": {
-                        "read": { "$ref": "#/$defs/Read" },
+                        "read":  { "$ref": "#/$defs/Read" },
                         "write": { "$ref": "#/$defs/Write" }
                     }
-                }
-            },
-            "$defs": {
+                },
                 "Read": {
-                    "AlkType:Struct": true,
-                    "properties": {
-                        "type": { "AlkType:Uint8": true },
-                        "handle": { "AlkType:Uint32": true }
-                    }
+                    "kind": "struct",
+                    "fields": [
+                        { "name": "type",   "kind": "uint8" },
+                        { "name": "handle", "kind": "uint32" }
+                    ]
                 },
                 "Write": {
-                    "AlkType:Struct": true,
-                    "properties": {
-                        "type": { "AlkType:Uint8": true },
-                        "handle": { "AlkType:Uint32": true },
-                        "length": { "AlkType:Uint32": true }
-                    }
+                    "kind": "struct",
+                    "fields": [
+                        { "name": "type",   "kind": "uint8" },
+                        { "name": "handle", "kind": "uint32" },
+                        { "name": "length", "kind": "uint32" }
+                    ]
                 }
             }
         });
         let vs = var_sizes(&[("event.__variant", 1)]);
-        let layout = build(&schema, &vs);
+        let layout = build(&root, "S", &vs);
         assert_eq!(
             layout.get("event.length"),
             Some(&FieldPosition {
@@ -1388,375 +1361,175 @@ mod tests {
 
     #[test]
     fn union_field_name_missing_variant_index_is_offset_error() {
-        let schema = json!({
-            "AlkType:Struct": true,
-            "properties": {
-                "event": {
-                    "AlkType:Union": true,
+        let root = json!({
+            "$defs": {
+                "S": {
+                    "kind": "struct",
+                    "fields": [
+                        {
+                            "name": "event",
+                            "kind": { "$ref": "#/$defs/Event" }
+                        }
+                    ]
+                },
+                "Event": {
+                    "kind": "union",
                     "discriminator": { "kind": "field", "name": "type" },
+                    "fields": [ { "name": "type", "kind": "uint8" } ],
                     "mapping": {
                         "read": { "$ref": "#/$defs/Read" }
                     }
-                }
-            },
-            "$defs": {
+                },
                 "Read": {
-                    "AlkType:Struct": true,
-                    "properties": { "type": { "AlkType:Uint8": true } }
+                    "kind": "struct",
+                    "fields": [ { "name": "type", "kind": "uint8" } ]
                 }
             }
         });
-        let builder = LayoutBuilder::new(&schema).expect("builder");
+        let builder = LayoutBuilder::new(&root, "S").expect("builder");
         let err = builder.build(&var_sizes(&[])).unwrap_err();
         assert!(matches!(err, AlkTypeError::Offset { .. }));
     }
 
     #[test]
     fn union_field_name_variant_index_out_of_range_is_offset_error() {
-        let schema = json!({
-            "AlkType:Struct": true,
-            "properties": {
-                "event": {
-                    "AlkType:Union": true,
+        let root = json!({
+            "$defs": {
+                "S": {
+                    "kind": "struct",
+                    "fields": [
+                        {
+                            "name": "event",
+                            "kind": { "$ref": "#/$defs/Event" }
+                        }
+                    ]
+                },
+                "Event": {
+                    "kind": "union",
                     "discriminator": { "kind": "field", "name": "type" },
+                    "fields": [ { "name": "type", "kind": "uint8" } ],
                     "mapping": {
                         "read": { "$ref": "#/$defs/Read" }
                     }
-                }
-            },
-            "$defs": {
+                },
                 "Read": {
-                    "AlkType:Struct": true,
-                    "properties": { "type": { "AlkType:Uint8": true } }
+                    "kind": "struct",
+                    "fields": [ { "name": "type", "kind": "uint8" } ]
                 }
             }
         });
         let vs = var_sizes(&[("event.__variant", 5)]);
-        let builder = LayoutBuilder::new(&schema).expect("builder");
+        let builder = LayoutBuilder::new(&root, "S").expect("builder");
         let err = builder.build(&vs).unwrap_err();
         assert!(matches!(err, AlkTypeError::Offset { .. }));
     }
 
     #[test]
     fn iter_returns_fields_in_layout_order() {
-        let schema = json!({
-            "AlkType:Struct": true,
-            "properties": {
-                "a": { "AlkType:Uint8": true },
-                "b": { "AlkType:Uint32": true },
-                "c": { "AlkType:Uint16": true }
+        let root = json!({
+            "$defs": {
+                "S": {
+                    "kind": "struct",
+                    "fields": [
+                        { "name": "a", "kind": "uint8" },
+                        { "name": "b", "kind": "uint32" },
+                        { "name": "c", "kind": "uint16" }
+                    ]
+                }
             }
         });
-        let layout = build(&schema, &var_sizes(&[]));
+        let layout = build(&root, "S", &var_sizes(&[]));
         let paths: Vec<&str> = layout.iter().map(|(p, _)| p.as_str()).collect();
         assert_eq!(paths, vec!["a", "b", "c"]);
     }
 
     #[test]
     fn iter_includes_nested_struct_fields() {
-        let schema = json!({
-            "AlkType:Struct": true,
-            "properties": {
-                "header": {
-                    "AlkType:Struct": true,
-                    "properties": {
-                        "magic": { "AlkType:Uint32": true },
-                        "version": { "AlkType:Uint8": true }
-                    }
-                },
-                "body": { "AlkType:Uint32": true }
+        let root = json!({
+            "$defs": {
+                "S": {
+                    "kind": "struct",
+                    "fields": [
+                        {
+                            "name": "header",
+                            "kind": {
+                                "kind": "struct",
+                                "fields": [
+                                    { "name": "magic",   "kind": "uint32" },
+                                    { "name": "version", "kind": "uint8" }
+                                ]
+                            }
+                        },
+                        { "name": "body", "kind": "uint32" }
+                    ]
+                }
             }
         });
-        let layout = build(&schema, &var_sizes(&[]));
+        let layout = build(&root, "S", &var_sizes(&[]));
         let paths: Vec<&str> = layout.iter().map(|(p, _)| p.as_str()).collect();
         assert_eq!(paths, vec!["header.magic", "header.version", "body"]);
     }
 
     #[test]
     fn get_returns_none_for_unknown_path() {
-        let schema = json!({
-            "AlkType:Struct": true,
-            "properties": {
-                "a": { "AlkType:Uint8": true }
+        let root = json!({
+            "$defs": {
+                "S": {
+                    "kind": "struct",
+                    "fields": [ { "name": "a", "kind": "uint8" } ]
+                }
             }
         });
-        let layout = build(&schema, &var_sizes(&[]));
+        let layout = build(&root, "S", &var_sizes(&[]));
         assert!(layout.get("missing").is_none());
     }
 
     #[test]
-    fn endian_parsed_from_schema() {
-        let schema = json!({
-            "AlkType:Struct": true,
-            "endian": "big",
-            "properties": {
-                "id": { "AlkType:Uint32": true }
+    fn new_rejects_non_struct_top_level() {
+        let root = json!({
+            "$defs": {
+                "U": {
+                    "kind": "union",
+                    "discriminator": { "kind": "byte", "offset": 0, "type": "uint8" },
+                    "mapping": { "1": { "$ref": "#/$defs/A" } }
+                },
+                "A": { "kind": "struct", "fields": [] }
             }
         });
-        let builder = LayoutBuilder::new(&schema).expect("builder");
-        assert_eq!(builder.endian(), Endian::Big);
+        let err = LayoutBuilder::new(&root, "U").unwrap_err();
+        assert!(matches!(err, AlkTypeError::Schema(_)));
+    }
+
+    #[test]
+    fn new_rejects_missing_root() {
+        let root = json!({ "$defs": { "Other": { "kind": "struct", "fields": [] } } });
+        let err = LayoutBuilder::new(&root, "Missing").unwrap_err();
+        assert!(matches!(err, AlkTypeError::Schema(_)));
     }
 
     #[test]
     fn endian_defaults_to_little() {
-        let schema = json!({
-            "AlkType:Struct": true,
-            "properties": {
-                "id": { "AlkType:Uint32": true }
+        let root = json!({
+            "$defs": {
+                "S": { "kind": "struct", "fields": [ { "name": "id", "kind": "uint32" } ] }
             }
         });
-        let builder = LayoutBuilder::new(&schema).expect("builder");
+        let builder = LayoutBuilder::new(&root, "S").expect("builder");
         assert_eq!(builder.endian(), Endian::Little);
     }
 
     #[test]
-    fn new_rejects_non_struct_top_level() {
-        let schema = json!({ "AlkType:Uint32": true });
-        let err = LayoutBuilder::new(&schema).unwrap_err();
-        assert!(matches!(err, AlkTypeError::Schema(_)));
-    }
-
-    #[test]
-    fn new_rejects_missing_alktype_kind() {
-        let schema = json!({ "type": "object", "properties": {} });
-        let err = LayoutBuilder::new(&schema).unwrap_err();
-        assert!(matches!(err, AlkTypeError::Schema(_)));
-    }
-
-    #[test]
-    fn build_rejects_struct_without_properties() {
-        let schema = json!({ "AlkType:Struct": true });
-        let builder = LayoutBuilder::new(&schema).expect("builder");
-        let err = builder.build(&var_sizes(&[])).unwrap_err();
-        assert!(matches!(err, AlkTypeError::Schema(_)));
-    }
-
-    #[test]
-    fn build_rejects_field_without_alktype_kind() {
-        let schema = json!({
-            "AlkType:Struct": true,
-            "properties": {
-                "a": { "type": "integer" }
-            }
-        });
-        let builder = LayoutBuilder::new(&schema).expect("builder");
-        let err = builder.build(&var_sizes(&[])).unwrap_err();
-        assert!(matches!(err, AlkTypeError::Offset { .. }));
-    }
-
-    #[test]
-    fn object_form_keyword_is_recognized() {
-        let schema = json!({
-            "AlkType:Struct": true,
-            "properties": {
-                "name": { "AlkType:String": { "encoding": "length-prefixed" } }
-            }
-        });
-        let layout = build(&schema, &var_sizes(&[("name", 5)]));
-        assert_eq!(
-            layout.get("name"),
-            Some(&FieldPosition {
-                offset: 0,
-                size: 4,
-                kind: AlkTypeKind::String
-            })
-        );
-        assert_eq!(layout.total_size(), 9);
-    }
-
-    #[test]
-    fn all_fixed_size_kinds_get_correct_sizes() {
-        let schema = json!({
-            "AlkType:Struct": true,
-            "properties": {
-                "i8":  { "AlkType:Int8": true },
-                "i16": { "AlkType:Int16": true },
-                "i32": { "AlkType:Int32": true },
-                "u8":  { "AlkType:Uint8": true },
-                "u16": { "AlkType:Uint16": true },
-                "u32": { "AlkType:Uint32": true },
-                "f32": { "AlkType:Float32": true },
-                "f64": { "AlkType:Float64": true },
-                "b":   { "AlkType:Boolean": true },
-                "e":   { "AlkType:Enum": true }
-            }
-        });
-        let layout = build(&schema, &var_sizes(&[]));
-        assert_eq!(layout.get("i8").unwrap().size, 1);
-        assert_eq!(layout.get("i16").unwrap().size, 2);
-        assert_eq!(layout.get("i32").unwrap().size, 4);
-        assert_eq!(layout.get("u8").unwrap().size, 1);
-        assert_eq!(layout.get("u16").unwrap().size, 2);
-        assert_eq!(layout.get("u32").unwrap().size, 4);
-        assert_eq!(layout.get("f32").unwrap().size, 4);
-        assert_eq!(layout.get("f64").unwrap().size, 8);
-        assert_eq!(layout.get("b").unwrap().size, 1);
-        assert_eq!(layout.get("e").unwrap().size, 4);
-        assert_eq!(layout.total_size(), 1 + 2 + 4 + 1 + 2 + 4 + 4 + 8 + 1 + 4);
-    }
-
-    #[test]
-    fn empty_struct_produces_zero_size_layout() {
-        let schema = json!({
-            "AlkType:Struct": true,
-            "properties": {}
-        });
-        let layout = build(&schema, &var_sizes(&[]));
-        assert_eq!(layout.total_size(), 0);
-        assert_eq!(layout.iter().count(), 0);
-    }
-
-    #[test]
-    fn inline_variant_schema_works_without_ref() {
-        let schema = json!({
-            "AlkType:Struct": true,
-            "properties": {
-                "packet": {
-                    "AlkType:Union": true,
-                    "discriminator": {
-                        "kind": "byte",
-                        "offset": 0,
-                        "type": "AlkType:Uint8"
-                    },
-                    "mapping": {
-                        "5": {
-                            "AlkType:Struct": true,
-                            "properties": {
-                                "x": { "AlkType:Uint32": true }
-                            }
-                        }
-                    }
-                }
-            }
-        });
-        let vs = var_sizes(&[("packet.__discriminator", 5)]);
-        let layout = build(&schema, &vs);
-        assert_eq!(
-            layout.get("packet.__discriminator"),
-            Some(&FieldPosition {
-                offset: 0,
-                size: 1,
-                kind: AlkTypeKind::Uint8
-            })
-        );
-        assert_eq!(
-            layout.get("packet.x"),
-            Some(&FieldPosition {
-                offset: 1,
-                size: 4,
-                kind: AlkTypeKind::Uint32
-            })
-        );
-        assert_eq!(layout.total_size(), 5);
-    }
-
-    #[test]
-    fn union_nested_inside_struct_after_preceding_field() {
-        let schema = json!({
-            "AlkType:Struct": true,
-            "properties": {
-                "id": { "AlkType:Uint8": true },
-                "payload": {
-                    "AlkType:Union": true,
-                    "discriminator": {
-                        "kind": "byte",
-                        "offset": 0,
-                        "type": "AlkType:Uint8"
-                    },
-                    "mapping": {
-                        "5": { "$ref": "#/$defs/Read" }
-                    }
-                }
-            },
+    fn endian_parsed_from_struct() {
+        let root = json!({
             "$defs": {
-                "Read": {
-                    "AlkType:Struct": true,
-                    "properties": {
-                        "handle": { "AlkType:Uint32": true }
-                    }
+                "S": {
+                    "kind": "struct",
+                    "endian": "big",
+                    "fields": [ { "name": "id", "kind": "uint32" } ]
                 }
             }
         });
-        let vs = var_sizes(&[("payload.__discriminator", 5)]);
-        let layout = build(&schema, &vs);
-        assert_eq!(
-            layout.get("id"),
-            Some(&FieldPosition {
-                offset: 0,
-                size: 1,
-                kind: AlkTypeKind::Uint8
-            })
-        );
-        assert_eq!(
-            layout.get("payload.__discriminator"),
-            Some(&FieldPosition {
-                offset: 1,
-                size: 1,
-                kind: AlkTypeKind::Uint8
-            })
-        );
-        assert_eq!(
-            layout.get("payload.handle"),
-            Some(&FieldPosition {
-                offset: 2,
-                size: 4,
-                kind: AlkTypeKind::Uint32
-            })
-        );
-        assert_eq!(layout.total_size(), 6);
+        let builder = LayoutBuilder::new(&root, "S").expect("builder");
+        assert_eq!(builder.endian(), Endian::Big);
     }
-
-    #[test]
-    fn union_byte_discriminator_variant_must_be_struct() {
-        let schema = json!({
-            "AlkType:Struct": true,
-            "properties": {
-                "payload": {
-                    "AlkType:Union": true,
-                    "discriminator": {
-                        "kind": "byte",
-                        "offset": 0,
-                        "type": "AlkType:Uint8"
-                    },
-                    "mapping": {
-                        "5": { "AlkType:Uint32": true }
-                    }
-                }
-            }
-        });
-        let vs = var_sizes(&[("payload.__discriminator", 5)]);
-        let builder = LayoutBuilder::new(&schema).expect("builder");
-        let err = builder.build(&vs).unwrap_err();
-        match err {
-            AlkTypeError::Offset { reason, .. } => {
-                assert!(reason.contains("variant must be AlkType:Struct"), "reason: {reason}");
-            }
-            other => panic!("expected Offset, got {other:?}"),
-        }
-    }
-
-    #[test]
-    fn union_field_discriminator_variant_must_be_struct() {
-        let schema = json!({
-            "AlkType:Struct": true,
-            "properties": {
-                "event": {
-                    "AlkType:Union": true,
-                    "discriminator": { "kind": "field", "name": "type" },
-                    "mapping": {
-                        "read": { "AlkType:Uint32": true }
-                    }
-                }
-            }
-        });
-        let vs = var_sizes(&[("event.__variant", 0)]);
-        let builder = LayoutBuilder::new(&schema).expect("builder");
-        let err = builder.build(&vs).unwrap_err();
-        match err {
-            AlkTypeError::Offset { reason, .. } => {
-                assert!(reason.contains("variant must be AlkType:Struct"), "reason: {reason}");
-            }
-            other => panic!("expected Offset, got {other:?}"),
-        }
-    }
-}
+}
\ No newline at end of file
diff --git a/src/lib.rs b/src/lib.rs
index 267edd0..fa22922 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -1,30 +1,37 @@
 //! alktype: The binary struct engine.
 //!
-//! Takes a JSON Schema with `AlkType:*` custom keywords and produces
+//! Takes a BAST (Binary Abstract Syntax Tree) document and produces
 //! an offset map, read/write functions, and validation — all driven
 //! by the schema. The schema is the format definition; the engine is
 //! generic.
 //!
 //! ## Architecture
 //!
-//! - **Schema layer** ([`schema`]): AlkType kind detection, annotation
-//!   parsing, `$ref` normalization, endianness.
+//! - **BAST parser** ([`bast`]): Typed tree over a BAST document —
+//!   `BastDoc`/`BastDef`/`BastStruct`/`BastField`/`BastType`/etc.
+//!   Borrows from the source `serde_json::Value` without cloning field
+//!   data.
 //! - **Layout engine** ([`offset_map`], [`layout_builder`],
 //!   [`sequential_reader`]): Two layout modes — aligned static for
 //!   mmap-friendly formats, packed sequential for protocol wire formats.
+//!   All three consume the BAST typed tree.
 //! - **Data access** ([`data_access`]): Typed read/write at computed
 //!   offsets, zero-copy for fixed-size types.
 //! - **TUnion dispatch** ([`tunion`]): Byte-offset and field-name
-//!   discriminator dispatch.
+//!   discriminator dispatch over `BastUnion`.
 //! - **Validation** ([`validation`]): Custom keyword validators for all
-//!   19 `AlkType:*` kinds, delegated to the `jsonschema` crate.
+//!   19 `AlkType:*` kinds, delegated to the `jsonschema` crate. (Step 5
+//!   replaces the `validate_bytes` path with a BAST-native validator;
+//!   step 6 reworks `validate_json` to use a consumer-provided standard
+//!   JSON Schema.)
 //! - **Builder** ([`builder`]): Fluent Rust API for constructing alktype
 //!   JSON Schemas at runtime, producing `serde_json::Value` (ADR-009).
+//!   (Step 7 converts the builder to emit BAST JSON.)
 //! - **Materialize** ([`materialize`]): Materialize a `serde_json::Value`
-//!   tree from a binary buffer by walking the schema. Used by
+//!   tree from a binary buffer by walking the BAST typed tree. Used by
 //!   `AlkTypeEngine::validate_bytes` (ADR-010).
 //! - **Engine** ([`engine`]): `AlkTypeEngine` — the compiled form of a
-//!   schema, combining layout and validation.
+//!   BAST document, combining layout and validation.
 
 #[macro_use]
 mod macros;
diff --git a/src/materialize.rs b/src/materialize.rs
index 9b53c29..bc69299 100644
--- a/src/materialize.rs
+++ b/src/materialize.rs
@@ -1,7 +1,8 @@
 //! Materialize a `serde_json::Value` tree from a binary buffer by walking
-//! the schema. Used by [`crate::engine::AlkTypeEngine::validate_bytes`]
-//! (ADR-010) to collapse the two-step dance (read bytes -> `Value`,
-//! then validate `Value`) into a single call.
+//! the BAST typed tree. Used by
+//! [`crate::engine::AlkTypeEngine::validate_bytes`] (ADR-010) to collapse
+//! the two-step dance (read bytes -> `Value`, then validate `Value`) into
+//! a single call.
 //!
 //! The materializer reuses the [`crate::data_access`] read functions for
 //! leaf kinds and recurses into composites (`Struct`, `Array`, `Record`,
@@ -14,417 +15,410 @@
 //!
 //! ## `$ref` resolution
 //!
-//! The root schema is threaded through every recursive call so that
-//! `$ref` pointers (e.g. `"#/$defs/Read"`) in composite variants can be
-//! resolved against the schema root via
-//! [`crate::schema::resolve_ref_or_inline`]. This is load-bearing for
+//! The BAST document ([`crate::bast::BastDoc`]) is threaded through every
+//! recursive call so that `$ref` pointers (e.g. `"#/$defs/Read"`) in
+//! composite variants can be resolved via
+//! [`crate::bast::BastDoc::resolve_typeref`]. This is load-bearing for
 //! unions and arrays whose variants/elements are `$ref`s into `$defs`
 //! (the SFTP Packet shape: a struct wrapping a union with `$ref`
 //! variants).
 
+use crate::bast::{
+    BastArray, BastDefKind, BastDiscriminator, BastDoc, BastField, BastRecord, BastStruct,
+    BastType, BastUnion,
+};
 use crate::data_access;
 use crate::error::AlkTypeError;
-use crate::schema::{
-    get_alktype_kind_loose_enum, resolve_ref_or_inline, DiscriminatorKind, Endian, AlkTypeKind,
-};
+use crate::schema::{AlkTypeKind, Endian};
 use serde_json::{Map, Value};
 
 const U32_SIZE: usize = 4;
+const DISCRIMINATOR_KEY: &str = "__discriminator";
 
-/// Materialize a `Value` tree from `buffer` by walking `schema` in packed
-/// mode (sequential, from offset 0).
+/// Materialize a `Value` tree from `buffer` by walking the BAST root type
+/// in packed mode (sequential, from offset 0).
 ///
-/// `schema` must declare `AlkType:Struct` at the root (the same
-/// requirement as [`crate::sequential_reader::SequentialReader::new`]).
-/// `endian` is the schema's endianness (parsed by the caller). The
-/// `schema` is also used as the root for `$ref` resolution.
+/// The root type must be a struct. `endian` is the schema's endianness
+/// (parsed by the caller); a struct-level `endian` annotation overrides
+/// it for the root and all nested structs.
 pub fn materialize_packed(
+    doc: &BastDoc<'_>,
     buffer: &[u8],
-    schema: &Value,
     endian: Endian,
 ) -> Result<Value, AlkTypeError> {
-    materialize_struct_packed(buffer, schema, schema, "", endian)
+    let root_def = doc.root_def();
+    let struct_node = match root_def.kind() {
+        BastDefKind::Struct(s) => s,
+        other => {
+            return Err(AlkTypeError::Schema(format!(
+                "materialize_packed: expected a struct at the root, got {kind}",
+                kind = other.alk_kind()
+            )));
+        }
+    };
+    let effective_endian = struct_node.endian();
+    let _ = endian;
+    materialize_struct_packed(doc, struct_node, "", effective_endian, buffer, &mut 0)
 }
 
-/// Materialize a `Value` tree from `buffer` by walking `schema` in aligned
-/// mode (offsets from `offset_map`).
+/// Materialize a `Value` tree from `buffer` by walking the BAST root type
+/// in aligned mode (offsets from `offset_map`).
 ///
-/// `schema` must declare `AlkType:Struct` at the root. `offset_map` must
-/// have been computed from the same `schema`. `endian` is the schema's
-/// endianness. The `schema` is also used as the root for `$ref` resolution.
+/// The root type must be a struct. `offset_map` must have been computed
+/// from the same BAST document. `endian` is the schema's endianness.
 pub fn materialize_aligned(
+    doc: &BastDoc<'_>,
     buffer: &[u8],
-    schema: &Value,
     offset_map: &crate::offset_map::OffsetMap,
     endian: Endian,
 ) -> Result<Value, AlkTypeError> {
-    materialize_struct_aligned(buffer, schema, schema, "", offset_map, endian)
+    let root_def = doc.root_def();
+    let struct_node = match root_def.kind() {
+        BastDefKind::Struct(s) => s,
+        other => {
+            return Err(AlkTypeError::Schema(format!(
+                "materialize_aligned: expected a struct at the root, got {kind}",
+                kind = other.alk_kind()
+            )));
+        }
+    };
+    let effective_endian = struct_node.endian();
+    let _ = endian;
+    materialize_struct_aligned(doc, struct_node, "", offset_map, effective_endian, buffer)
 }
 
 fn materialize_struct_packed(
-    buffer: &[u8],
-    root: &Value,
-    struct_schema: &Value,
+    doc: &BastDoc<'_>,
+    struct_node: &BastStruct<'_>,
     path_prefix: &str,
     endian: Endian,
+    buffer: &[u8],
+    offset: &mut usize,
 ) -> Result<Value, AlkTypeError> {
-    let struct_schema = resolve_ref_or_inline(struct_schema, root).unwrap_or(struct_schema);
-    let kind = get_alktype_kind_loose_enum(struct_schema).ok_or_else(|| {
-        AlkTypeError::Schema(format!(
-            "materialize: schema at {path_prefix} has no AlkType:* kind"
-        ))
-    })?;
-    if kind != AlkTypeKind::Struct {
-        return Err(AlkTypeError::Schema(format!(
-            "materialize_struct_packed: expected AlkType:Struct at {path_prefix}, got {kind}"
-        )));
-    }
-    let props = struct_schema
-        .get("properties")
-        .and_then(Value::as_object)
-        .ok_or_else(|| {
-            AlkTypeError::Schema(format!(
-                "materialize: struct at {path_prefix} has no properties"
-            ))
-        })?;
     let mut obj = Map::new();
-    let mut offset = 0usize;
-    for (name, field_schema) in props.iter() {
+    for field in struct_node.fields() {
         let path = if path_prefix.is_empty() {
-            name.clone()
+            field.name().to_string()
         } else {
-            format!("{path_prefix}.{name}")
+            format!("{path_prefix}.{}", field.name())
         };
-        let (value, new_offset) =
-            materialize_field_packed(buffer, root, field_schema, &path, offset, endian)?;
-        obj.insert(name.clone(), value);
-        offset = new_offset;
+        let field_endian = field.effective_endian(endian);
+        let value = materialize_field_packed(doc, field, &path, field_endian, buffer, offset)?;
+        obj.insert(field.name().to_string(), value);
     }
     Ok(Value::Object(obj))
 }
 
 fn materialize_field_packed(
-    buffer: &[u8],
-    root: &Value,
-    field_schema: &Value,
+    doc: &BastDoc<'_>,
+    field: &BastField<'_>,
     field_path: &str,
-    offset: usize,
     endian: Endian,
-) -> Result<(Value, usize), AlkTypeError> {
-    // Resolve $ref against the root before checking the kind. A
-    // $ref-bearing node has no AlkType:* kind; the kind lives on the
-    // resolved target. This is load-bearing for union variants and
-    // array elements that reference $defs.
-    let resolved = resolve_ref_or_inline(field_schema, root).unwrap_or(field_schema);
-    let kind = get_alktype_kind_loose_enum(resolved).ok_or_else(|| {
-        AlkTypeError::Schema(format!(
-            "materialize: field {field_path} has no AlkType:* kind: {field_schema}"
-        ))
-    })?;
-    match kind {
-        AlkTypeKind::Int8 => {
-            let v = data_access::read_i8(buffer, offset, field_path)?;
-            Ok((Value::from(v), offset + 1))
-        }
-        AlkTypeKind::Int16 => {
-            let v = data_access::read_i16(buffer, offset, field_path, endian)?;
-            Ok((Value::from(v), offset + 2))
-        }
-        AlkTypeKind::Int32 => {
-            let v = data_access::read_i32(buffer, offset, field_path, endian)?;
-            Ok((Value::from(v), offset + 4))
-        }
-        AlkTypeKind::Int64 => {
-            let v = data_access::read_i64(buffer, offset, field_path, endian)?;
-            Ok((Value::from(v), offset + 8))
-        }
-        AlkTypeKind::Uint8 => {
-            let v = data_access::read_u8(buffer, offset, field_path)?;
-            Ok((Value::from(v), offset + 1))
-        }
-        AlkTypeKind::Uint16 => {
-            let v = data_access::read_u16(buffer, offset, field_path, endian)?;
-            Ok((Value::from(v), offset + 2))
-        }
-        AlkTypeKind::Uint32 => {
-            let v = data_access::read_u32(buffer, offset, field_path, endian)?;
-            Ok((Value::from(v), offset + 4))
-        }
-        AlkTypeKind::Uint64 => {
-            let v = data_access::read_u64(buffer, offset, field_path, endian)?;
-            Ok((Value::from(v), offset + 8))
-        }
-        AlkTypeKind::Float32 => {
-            let v = data_access::read_f32(buffer, offset, field_path, endian)?;
-            Ok((
-                serde_json::Number::from_f64(v as f64)
-                    .map(Value::Number)
-                    .unwrap_or(Value::Null),
-                offset + 4,
-            ))
-        }
-        AlkTypeKind::Float64 => {
-            let v = data_access::read_f64(buffer, offset, field_path, endian)?;
-            Ok((
-                serde_json::Number::from_f64(v)
-                    .map(Value::Number)
-                    .unwrap_or(Value::Null),
-                offset + 8,
-            ))
-        }
-        AlkTypeKind::Boolean => {
-            let v = data_access::read_bool(buffer, offset, field_path)?;
-            Ok((Value::Bool(v), offset + 1))
-        }
-        AlkTypeKind::Enum => {
-            let v = data_access::read_enum(buffer, offset, field_path, endian)?;
-            Ok((Value::from(v), offset + 4))
-        }
-        AlkTypeKind::String => {
-            let s = data_access::read_string(buffer, offset, field_path, endian)?;
-            Ok((Value::String(s.to_string()), offset + U32_SIZE + s.len()))
-        }
-        AlkTypeKind::Bytes => {
-            let b = data_access::read_bytes(buffer, offset, field_path, endian)?;
-            // Materialize as a JSON array of u8 (one Value::Number per
-            // byte, 0..=255). This is the round-trippable form for raw
-            // bytes — JSON has no native byte type, and `from_utf8_lossy`
-            // corrupts non-UTF-8 byte sequences (breaking `maxLength`
-            // semantics, since the replacement char U+FFFD is 3 bytes in
-            // UTF-8). The `BytesValidator` accepts `Value::Array` for
-            // `validate_bytes` and `Value::String` for `validate_json`
-            // (so JSON consumers can still pass a string). `maxLength`
-            // is interpreted as max byte count (array length).
-            let arr: Vec<Value> = b.iter().map(|&byte| Value::from(u32::from(byte))).collect();
-            Ok((Value::Array(arr), offset + U32_SIZE + b.len()))
-        }
-        AlkTypeKind::Timestamp => {
-            let s = data_access::read_string(buffer, offset, field_path, endian)?;
-            Ok((Value::String(s.to_string()), offset + U32_SIZE + s.len()))
-        }
-        AlkTypeKind::Struct => {
-            // Recurse: materialize the nested struct starting at `offset`.
-            // The nested struct's fields follow inline. We don't know its
-            // total size without walking it, so we recurse and let it
-            // return the new offset.
-            materialize_struct_packed_at(buffer, root, resolved, field_path, offset, endian)
-        }
-        AlkTypeKind::Array => {
-            materialize_array_packed(buffer, root, resolved, field_path, offset, endian)
-        }
-        AlkTypeKind::Union => {
-            materialize_union_packed(buffer, root, resolved, field_path, offset, endian)
-        }
-        AlkTypeKind::Record => {
-            materialize_record_packed(buffer, root, resolved, field_path, offset, endian)
-        }
-    }
+    buffer: &[u8],
+    offset: &mut usize,
+) -> Result<Value, AlkTypeError> {
+    let field_endian = field.effective_endian(endian);
+    let ty = field.ty();
+    let resolved = doc.resolve_typeref(ty)?;
+    materialize_typeref_packed(doc, &resolved, field, field_path, field_endian, buffer, offset)
 }
 
-fn materialize_struct_packed_at(
-    buffer: &[u8],
-    root: &Value,
-    struct_schema: &Value,
-    path_prefix: &str,
-    offset: usize,
+fn materialize_typeref_packed(
+    doc: &BastDoc<'_>,
+    ty: &BastType<'_>,
+    _field: &BastField<'_>,
+    field_path: &str,
     endian: Endian,
-) -> Result<(Value, usize), AlkTypeError> {
-    let struct_schema = resolve_ref_or_inline(struct_schema, root).unwrap_or(struct_schema);
-    let props = struct_schema
-        .get("properties")
-        .and_then(Value::as_object)
-        .ok_or_else(|| {
-            AlkTypeError::Schema(format!(
-                "materialize: struct at {path_prefix} has no properties"
-            ))
-        })?;
-    let mut obj = Map::new();
-    let mut cur = offset;
-    for (name, field_schema) in props.iter() {
-        let path = format!("{path_prefix}.{name}");
-        let (value, new_offset) =
-            materialize_field_packed(buffer, root, field_schema, &path, cur, endian)?;
-        obj.insert(name.clone(), value);
-        cur = new_offset;
+    buffer: &[u8],
+    offset: &mut usize,
+) -> Result<Value, AlkTypeError> {
+    match ty {
+        BastType::Primitive(AlkTypeKind::Int8) => {
+            let v = data_access::read_i8(buffer, *offset, field_path)?;
+            *offset += 1;
+            Ok(Value::from(v))
+        }
+        BastType::Primitive(AlkTypeKind::Int16) => {
+            let v = data_access::read_i16(buffer, *offset, field_path, endian)?;
+            *offset += 2;
+            Ok(Value::from(v))
+        }
+        BastType::Primitive(AlkTypeKind::Int32) => {
+            let v = data_access::read_i32(buffer, *offset, field_path, endian)?;
+            *offset += 4;
+            Ok(Value::from(v))
+        }
+        BastType::Primitive(AlkTypeKind::Int64) => {
+            let v = data_access::read_i64(buffer, *offset, field_path, endian)?;
+            *offset += 8;
+            Ok(Value::from(v))
+        }
+        BastType::Primitive(AlkTypeKind::Uint8) => {
+            let v = data_access::read_u8(buffer, *offset, field_path)?;
+            *offset += 1;
+            Ok(Value::from(v))
+        }
+        BastType::Primitive(AlkTypeKind::Uint16) => {
+            let v = data_access::read_u16(buffer, *offset, field_path, endian)?;
+            *offset += 2;
+            Ok(Value::from(v))
+        }
+        BastType::Primitive(AlkTypeKind::Uint32) => {
+            let v = data_access::read_u32(buffer, *offset, field_path, endian)?;
+            *offset += 4;
+            Ok(Value::from(v))
+        }
+        BastType::Primitive(AlkTypeKind::Uint64) => {
+            let v = data_access::read_u64(buffer, *offset, field_path, endian)?;
+            *offset += 8;
+            Ok(Value::from(v))
+        }
+        BastType::Primitive(AlkTypeKind::Float32) => {
+            let v = data_access::read_f32(buffer, *offset, field_path, endian)?;
+            *offset += 4;
+            Ok(number_from_f64(v as f64))
+        }
+        BastType::Primitive(AlkTypeKind::Float64) => {
+            let v = data_access::read_f64(buffer, *offset, field_path, endian)?;
+            *offset += 8;
+            Ok(number_from_f64(v))
+        }
+        BastType::Primitive(AlkTypeKind::Boolean) => {
+            let v = data_access::read_bool(buffer, *offset, field_path)?;
+            *offset += 1;
+            Ok(Value::Bool(v))
+        }
+        BastType::Enum(_) => {
+            let v = data_access::read_enum(buffer, *offset, field_path, endian)?;
+            *offset += 4;
+            Ok(Value::from(v))
+        }
+        BastType::Primitive(AlkTypeKind::String) => {
+            let s = data_access::read_string(buffer, *offset, field_path, endian)?;
+            let len = U32_SIZE + s.len();
+            *offset = offset.checked_add(len).ok_or_else(|| AlkTypeError::Access {
+                field_path: field_path.to_string(),
+                reason: format!("string offset {len} overflows usize"),
+            })?;
+            Ok(Value::String(s.to_string()))
+        }
+        BastType::Primitive(AlkTypeKind::Bytes) => {
+            let b = data_access::read_bytes(buffer, *offset, field_path, endian)?;
+            let len = U32_SIZE + b.len();
+            *offset = offset.checked_add(len).ok_or_else(|| AlkTypeError::Access {
+                field_path: field_path.to_string(),
+                reason: format!("bytes offset {len} overflows usize"),
+            })?;
+            let arr: Vec<Value> = b.iter().map(|&byte| Value::from(u32::from(byte))).collect();
+            Ok(Value::Array(arr))
+        }
+        BastType::Primitive(AlkTypeKind::Timestamp) => {
+            let s = data_access::read_string(buffer, *offset, field_path, endian)?;
+            let len = U32_SIZE + s.len();
+            *offset = offset.checked_add(len).ok_or_else(|| AlkTypeError::Access {
+                field_path: field_path.to_string(),
+                reason: format!("timestamp offset {len} overflows usize"),
+            })?;
+            Ok(Value::String(s.to_string()))
+        }
+        BastType::Struct(s) => {
+            materialize_struct_packed(doc, s, field_path, endian, buffer, offset)
+        }
+        BastType::Array(a) => {
+            materialize_array_packed(doc, a, field_path, endian, buffer, offset)
+        }
+        BastType::Union(u) => {
+            materialize_union_packed(doc, u, field_path, endian, buffer, offset)
+        }
+        BastType::Record(r) => {
+            materialize_record_packed(doc, r, field_path, endian, buffer, offset)
+        }
+        BastType::Ref(_) => Err(AlkTypeError::Schema(format!(
+            "materialize: unresolved $ref at {field_path}"
+        ))),
+        BastType::Primitive(k) => Err(AlkTypeError::Schema(format!(
+            "materialize: unsupported primitive kind {k} at {field_path}"
+        ))),
     }
-    Ok((Value::Object(obj), cur))
 }
 
 fn materialize_array_packed(
-    buffer: &[u8],
-    root: &Value,
-    field_schema: &Value,
+    doc: &BastDoc<'_>,
+    array: &BastArray<'_>,
     field_path: &str,
-    offset: usize,
     endian: Endian,
-) -> Result<(Value, usize), AlkTypeError> {
-    let element_schema = field_schema.get("items").ok_or_else(|| {
-        AlkTypeError::Schema(format!(
-            "materialize: array at {field_path} has no items schema"
-        ))
-    })?;
-    let min = field_schema.get("minItems").and_then(Value::as_u64);
-    let max = field_schema.get("maxItems").and_then(Value::as_u64);
-    let fixed_count = match (min, max) {
-        (Some(a), Some(b)) if a == b => Some(a as usize),
-        _ => None,
-    };
-    if let Some(count) = fixed_count {
-        let mut arr = Vec::with_capacity(count);
-        let mut cur = offset;
-        for i in 0..count {
-            let path = format!("{field_path}[{i}]");
-            let (value, new_offset) =
-                materialize_field_packed(buffer, root, element_schema, &path, cur, endian)?;
-            arr.push(value);
-            cur = new_offset;
-        }
-        Ok((Value::Array(arr), cur))
-    } else {
-        // Variable-count array: read a u32 count prefix, then `count` elements.
-        let count = data_access::read_u32(buffer, offset, field_path, endian)?;
-        let count = count as usize;
-        let mut arr = Vec::with_capacity(count);
-        let mut cur = offset + U32_SIZE;
-        for i in 0..count {
-            let path = format!("{field_path}[{i}]");
-            let (value, new_offset) =
-                materialize_field_packed(buffer, root, element_schema, &path, cur, endian)?;
-            arr.push(value);
-            cur = new_offset;
-        }
-        Ok((Value::Array(arr), cur))
+    buffer: &[u8],
+    offset: &mut usize,
+) -> Result<Value, AlkTypeError> {
+    let element_ty = array.element();
+    let count = array.count();
+    let mut arr = Vec::with_capacity(count);
+    for i in 0..count {
+        let path = format!("{field_path}[{i}]");
+        let resolved_elem = doc.resolve_typeref(element_ty)?;
+        let value = materialize_typeref_packed(
+            doc,
+            &resolved_elem,
+            &dummy_field_for(&resolved_elem),
+            &path,
+            endian,
+            buffer,
+            offset,
+        )?;
+        arr.push(value);
     }
+    Ok(Value::Array(arr))
 }
 
 fn materialize_union_packed(
-    buffer: &[u8],
-    root: &Value,
-    field_schema: &Value,
+    doc: &BastDoc<'_>,
+    union_node: &BastUnion<'_>,
     field_path: &str,
-    offset: usize,
     endian: Endian,
-) -> Result<(Value, usize), AlkTypeError> {
-    let disc = crate::schema::parse_discriminator(field_schema)?;
+    buffer: &[u8],
+    offset: &mut usize,
+) -> Result<Value, AlkTypeError> {
+    let disc = union_node.discriminator();
     match disc {
-        DiscriminatorKind::Byte {
-            offset: disc_offset,
-            disc_type,
-        } => {
-            let disc_abs_offset = offset.checked_add(disc_offset).ok_or_else(|| {
-                AlkTypeError::Access {
-                    field_path: field_path.to_string(),
-                    reason: format!(
-                        "discriminator offset {offset} + {disc_offset} overflows usize"
-                    ),
-                }
+        BastDiscriminator::Byte { offset: disc_rel, disc_type } => {
+            let disc_abs = offset.checked_add(*disc_rel).ok_or_else(|| AlkTypeError::Access {
+                field_path: field_path.to_string(),
+                reason: format!("discriminator offset {disc_rel} overflows"),
             })?;
             let disc_value = match disc_type {
                 AlkTypeKind::Uint8 => {
-                    data_access::read_u8(buffer, disc_abs_offset, field_path)? as u32
+                    data_access::read_u8(buffer, disc_abs, field_path)? as u32
                 }
                 AlkTypeKind::Uint16 => {
-                    data_access::read_u16(buffer, disc_abs_offset, field_path, endian)? as u32
+                    data_access::read_u16(buffer, disc_abs, field_path, endian)? as u32
                 }
                 AlkTypeKind::Uint32 => {
-                    data_access::read_u32(buffer, disc_abs_offset, field_path, endian)?
+                    data_access::read_u32(buffer, disc_abs, field_path, endian)?
                 }
                 other => {
                     return Err(AlkTypeError::Schema(format!(
                         "internal: union discriminator type {other} is not a supported byte \
-                         discriminator (parse_discriminator should have rejected this)"
+                         discriminator (parser should have rejected this)"
                     )));
                 }
             };
-            let mapping = field_schema.get("mapping").and_then(Value::as_object).ok_or_else(|| {
-                AlkTypeError::Schema(format!(
-                    "materialize: union at {field_path} has no mapping"
-                ))
-            })?;
+            let mapping = union_node.mapping();
             let key = disc_value.to_string();
-            let variant_schema = mapping.get(&key).ok_or_else(|| AlkTypeError::Access {
-                field_path: field_path.to_string(),
-                reason: format!("union discriminator value {key} not in mapping"),
-            })?;
+            let variant_ty = mapping
+                .iter()
+                .find(|(k, _)| *k == key)
+                .map(|(_, v)| v)
+                .ok_or_else(|| AlkTypeError::Access {
+                    field_path: field_path.to_string(),
+                    reason: format!("union discriminator value {key} not in mapping"),
+                })?;
             let disc_size = disc_type.type_size().unwrap_or(1);
-            let variant_offset = disc_abs_offset.checked_add(disc_size).ok_or_else(|| {
+            let variant_offset = disc_abs.checked_add(disc_size).ok_or_else(|| {
                 AlkTypeError::Access {
                     field_path: field_path.to_string(),
                     reason: format!(
-                        "variant offset {disc_abs_offset} + disc size {disc_size} overflows usize"
+                        "variant offset {disc_abs} + disc size {disc_size} overflows usize"
                     ),
                 }
             })?;
-            let (variant_value, new_offset) = materialize_field_packed(
-                buffer,
-                root,
-                variant_schema,
+            *offset = variant_offset;
+            let resolved_variant = doc.resolve_typeref(variant_ty)?;
+            let variant_value = materialize_typeref_packed(
+                doc,
+                &resolved_variant,
+                &dummy_field_for(&resolved_variant),
                 field_path,
-                variant_offset,
                 endian,
+                buffer,
+                offset,
             )?;
-            Ok((
-                tag_union_value(disc_value, variant_value),
-                new_offset,
-            ))
+            Ok(tag_union_value_number(disc_value, variant_value))
         }
-        DiscriminatorKind::Field { name } => {
-            // Field-name discriminator: the union is a struct whose first
-            // field is the discriminator; the variant struct follows. The
-            // discriminator field's value selects the mapping entry. The
-            // materialized shape is the same as the byte-offset path:
-            // `{ "__discriminator": <key>, <disc-field-name>: <typed-value>, ...variant-fields }`.
-            // The `__discriminator` entry carries the mapping key (stringified)
-            // for uniform validator dispatch; the discriminator field is
-            // preserved under its own name (it's a regular field in the
-            // struct — the typedef.ts pattern).
-            let properties = field_schema.get("properties").and_then(Value::as_object).ok_or_else(|| {
-                AlkTypeError::Schema(format!(
-                    "materialize: field-name union at {field_path} has no properties"
-                ))
-            })?;
-            let disc_schema = properties.get(&name).ok_or_else(|| {
-                AlkTypeError::Schema(format!(
-                    "materialize: union at {field_path} has no discriminator field '{name}'"
-                ))
-            })?;
+        BastDiscriminator::Field { name } => {
+            let fields = union_node.fields();
+            let disc_field = fields
+                .iter()
+                .find(|f| f.name() == *name)
+                .ok_or_else(|| {
+                    AlkTypeError::Schema(format!(
+                        "materialize: union at {field_path} has no discriminator field '{name}'"
+                    ))
+                })?;
             let disc_path = format!("{field_path}.{name}");
-            let (disc_value, after_disc) =
-                materialize_field_packed(buffer, root, disc_schema, &disc_path, offset, endian)?;
+            let disc_value =
+                materialize_field_packed(doc, disc_field, &disc_path, endian, buffer, offset)?;
             let key = union_discriminator_key(&disc_value, field_path)?;
-            let mapping = field_schema.get("mapping").and_then(Value::as_object).ok_or_else(|| {
-                AlkTypeError::Schema(format!(
-                    "materialize: union at {field_path} has no mapping"
-                ))
-            })?;
-            let variant_schema = mapping.get(&key).ok_or_else(|| AlkTypeError::Access {
-                field_path: field_path.to_string(),
-                reason: format!("union discriminator value {key} not in mapping"),
-            })?;
-            let (variant_value, new_offset) = materialize_field_packed(
-                buffer,
-                root,
-                variant_schema,
+            let mapping = union_node.mapping();
+            let variant_ty = mapping
+                .iter()
+                .find(|(k, _)| *k == key)
+                .map(|(_, v)| v)
+                .ok_or_else(|| AlkTypeError::Access {
+                    field_path: field_path.to_string(),
+                    reason: format!("union discriminator value {key} not in mapping"),
+                })?;
+            let resolved_variant = doc.resolve_typeref(variant_ty)?;
+            let variant_value = materialize_typeref_packed(
+                doc,
+                &resolved_variant,
+                &dummy_field_for(&resolved_variant),
                 field_path,
-                after_disc,
                 endian,
+                buffer,
+                offset,
             )?;
             let mut obj = Map::new();
-            obj.insert("__discriminator".to_string(), Value::String(key));
-            obj.insert(name.clone(), disc_value);
+            obj.insert(DISCRIMINATOR_KEY.to_string(), Value::String(key.clone()));
+            obj.insert((*name).to_string(), disc_value);
             flatten_variant_into(&mut obj, variant_value);
-            Ok((Value::Object(obj), new_offset))
+            Ok(Value::Object(obj))
         }
     }
 }
 
+fn materialize_record_packed(
+    doc: &BastDoc<'_>,
+    record: &BastRecord<'_>,
+    field_path: &str,
+    endian: Endian,
+    buffer: &[u8],
+    offset: &mut usize,
+) -> Result<Value, AlkTypeError> {
+    let values_ty = record.values();
+    let count = data_access::read_u32(buffer, *offset, field_path, endian)? as usize;
+    *offset += U32_SIZE;
+    let mut obj = Map::new();
+    for i in 0..count {
+        let key_path = format!("{field_path}[{i}].key");
+        let key_str = data_access::read_string(buffer, *offset, &key_path, endian)?;
+        let key_len = U32_SIZE + key_str.len();
+        *offset = offset.checked_add(key_len).ok_or_else(|| AlkTypeError::Access {
+            field_path: key_path.clone(),
+            reason: "key offset overflows".to_string(),
+        })?;
+        let val_path = format!("{field_path}[{i}].value");
+        let resolved_values = doc.resolve_typeref(values_ty)?;
+        let val = materialize_typeref_packed(
+            doc,
+            &resolved_values,
+            &dummy_field_for(&resolved_values),
+            &val_path,
+            endian,
+            buffer,
+            offset,
+        )?;
+        obj.insert(key_str.to_string(), val);
+    }
+    Ok(Value::Object(obj))
+}
+
 /// Build the materialized `Value` for a byte-offset union: an object
 /// `{ "__discriminator": <disc_value>, ...variant-fields }`. If the
 /// variant materialized as a non-object (a leaf), it is nested under
 /// `"__variant"`.
-fn tag_union_value(disc_value: u32, variant_value: Value) -> Value {
+fn tag_union_value_number(disc_value: u32, variant_value: Value) -> Value {
     let mut obj = Map::new();
-    obj.insert("__discriminator".to_string(), Value::from(disc_value));
+    obj.insert(DISCRIMINATOR_KEY.to_string(), Value::from(disc_value));
     flatten_variant_into(&mut obj, variant_value);
     Value::Object(obj)
 }
@@ -454,143 +448,113 @@ fn union_discriminator_key(value: &Value, field_path: &str) -> Result<String, Al
     }
 }
 
-/// Materialize an `AlkType:Record` field: a count-prefixed sequence of
-/// `(key, value)` pairs. Wire format per [schema-layer.md](../docs/architecture/schema-layer.md)
-/// §TRecord: `[count: u32][key_len: u32][key_bytes][value]...` repeated
-/// `count` times. The count and key-length prefixes respect `endian`.
-/// The value is materialized according to its declared `AlkType:*` kind.
-///
-/// The materialized form is a JSON object mapping each key (string) to
-/// its materialized value. This matches the `RecordValidator`'s
-/// expectation (an object whose values match the record's value type).
-fn materialize_record_packed(
-    buffer: &[u8],
-    root: &Value,
-    field_schema: &Value,
-    field_path: &str,
-    offset: usize,
-    endian: Endian,
-) -> Result<(Value, usize), AlkTypeError> {
-    let value_schema = field_schema.get("values").ok_or_else(|| {
-        AlkTypeError::Schema(format!(
-            "materialize: record at {field_path} has no values schema"
-        ))
-    })?;
-    let count = data_access::read_u32(buffer, offset, field_path, endian)? as usize;
-    let mut cur = offset + U32_SIZE;
-    let mut obj = Map::new();
-    for i in 0..count {
-        let key_path = format!("{field_path}[{i}].key");
-        let key_str = data_access::read_string(buffer, cur, &key_path, endian)?;
-        let key_len = U32_SIZE + key_str.len();
-        cur = cur
-            .checked_add(key_len)
-            .ok_or_else(|| AlkTypeError::Access {
-                field_path: key_path.clone(),
-                reason: format!("key offset {cur} + {key_len} overflows usize"),
-            })?;
-        let val_path = format!("{field_path}[{i}].value");
-        let (val, new_offset) =
-            materialize_field_packed(buffer, root, value_schema, &val_path, cur, endian)?;
-        obj.insert(key_str.to_string(), val);
-        cur = new_offset;
-    }
-    Ok((Value::Object(obj), cur))
+fn number_from_f64(f: f64) -> Value {
+    serde_json::Number::from_f64(f)
+        .map(Value::Number)
+        .unwrap_or(Value::Null)
 }
 
+/// Aligned-mode materialization: walk the BAST typed tree, but read
+/// leaves at offsets from the `OffsetMap` and fall back to packed-style
+/// sequential walks for composites (Array/Union/Record) whose internal
+/// layout can't be precomputed into the static offset map.
 fn materialize_struct_aligned(
-    buffer: &[u8],
-    root: &Value,
-    struct_schema: &Value,
+    doc: &BastDoc<'_>,
+    struct_node: &BastStruct<'_>,
     path_prefix: &str,
     offset_map: &crate::offset_map::OffsetMap,
     endian: Endian,
+    buffer: &[u8],
 ) -> Result<Value, AlkTypeError> {
-    let struct_schema = resolve_ref_or_inline(struct_schema, root).unwrap_or(struct_schema);
-    let props = struct_schema
-        .get("properties")
-        .and_then(Value::as_object)
-        .ok_or_else(|| {
-            AlkTypeError::Schema(format!(
-                "materialize: struct at {path_prefix} has no properties"
-            ))
-        })?;
     let mut obj = Map::new();
-    for (name, field_schema) in props.iter() {
+    for field in struct_node.fields() {
         let path = if path_prefix.is_empty() {
-            name.clone()
+            field.name().to_string()
         } else {
-            format!("{path_prefix}.{name}")
+            format!("{path_prefix}.{}", field.name())
         };
-        let resolved = resolve_ref_or_inline(field_schema, root).unwrap_or(field_schema);
-        let kind = get_alktype_kind_loose_enum(resolved).ok_or_else(|| {
-            AlkTypeError::Schema(format!(
-                "materialize: field {path} has no AlkType:* kind"
-            ))
-        })?;
+        let ty = field.ty();
+        let resolved = doc.resolve_typeref(ty)?;
+        let kind = resolved.alk_kind();
         let value = if kind.is_fixed_size() || kind.is_variable_length() {
-            // Leaf field — look up its byte range in the offset map.
             let range = offset_map.get(&path).ok_or_else(|| AlkTypeError::Offset {
                 field_path: path.clone(),
                 reason: "field not found in offset map".to_string(),
             })?;
-            materialize_leaf_at(buffer, root, resolved, &path, range.start, endian)?
+            materialize_leaf_at(doc, &resolved, &path, range.start, endian, buffer)?
         } else if kind == AlkTypeKind::Struct {
-            // Nested struct — recurse with the same offset map (nested
-            // fields are recorded under `path.*`).
-            materialize_struct_aligned(buffer, root, resolved, &path, offset_map, endian)?
+            if let BastType::Struct(s) = &resolved {
+                materialize_struct_aligned(doc, s, &path, offset_map, endian, buffer)?
+            } else {
+                return Err(AlkTypeError::Schema(format!(
+                    "materialize: resolved kind Struct but type was {resolved} at {path}"
+                )));
+            }
         } else {
-            // Composite leaf (Array, Union, Record) — fall back to packed-style
-            // walk from the field's start offset. The offset map records the
-            // field's start; the composite's internal layout is walked
-            // sequentially from that start (variable-length elements can't
-            // be precomputed into the static offset map).
             let range = offset_map.get(&path).ok_or_else(|| AlkTypeError::Offset {
                 field_path: path.clone(),
                 reason: "field not found in offset map".to_string(),
             })?;
-            let (value, _) =
-                materialize_field_packed(buffer, root, resolved, &path, range.start, endian)?;
-            value
+            let mut offset = range.start;
+            materialize_typeref_packed(
+                doc,
+                &resolved,
+                field,
+                &path,
+                endian,
+                buffer,
+                &mut offset,
+            )?
         };
-        obj.insert(name.clone(), value);
+        obj.insert(field.name().to_string(), value);
     }
     Ok(Value::Object(obj))
 }
 
 fn materialize_leaf_at(
-    buffer: &[u8],
-    root: &Value,
-    field_schema: &Value,
+    doc: &BastDoc<'_>,
+    ty: &BastType<'_>,
     field_path: &str,
     offset: usize,
     endian: Endian,
+    buffer: &[u8],
 ) -> Result<Value, AlkTypeError> {
-    let (_kind, value) =
-        materialize_field_packed_returning_kind(buffer, root, field_schema, field_path, offset, endian)?;
-    Ok(value)
+    let mut pos = offset;
+    materialize_typeref_packed(
+        doc,
+        ty,
+        &dummy_field_for(ty),
+        field_path,
+        endian,
+        buffer,
+        &mut pos,
+    )
 }
 
-/// Helper for aligned mode: materialize a leaf field, also returning the
-/// resolved kind so the caller can decide whether to recurse (struct) or
-/// treat as leaf. Defined inline to keep the materialize_field_packed
-/// signature stable.
-fn materialize_field_packed_returning_kind(
-    buffer: &[u8],
-    root: &Value,
-    field_schema: &Value,
-    field_path: &str,
-    offset: usize,
-    endian: Endian,
-) -> Result<(AlkTypeKind, Value), AlkTypeError> {
-    let resolved = resolve_ref_or_inline(field_schema, root).unwrap_or(field_schema);
-    let kind = get_alktype_kind_loose_enum(resolved).ok_or_else(|| {
-        AlkTypeError::Schema(format!(
-            "materialize: field {field_path} has no AlkType:* kind"
-        ))
-    })?;
-    let (value, _) = materialize_field_packed(buffer, root, field_schema, field_path, offset, endian)?;
-    Ok((kind, value))
+/// Construct a synthetic `BastField` borrowing from a resolved
+/// `BastType`'s source node. Used when materializing array elements /
+/// record values / union variants — these are TypeRefs, not fields, so
+/// they don't carry field-level annotations. The synthetic field
+/// inherits no annotations (which is correct: `maxLength`/`encoding`/
+/// `endian`/`align` are field-level properties, and array elements and
+/// record values don't have them in BAST).
+///
+/// The `BastField::parse` path validates the node; this helper bypasses
+/// re-validation for a node we've already resolved. The returned field
+/// borrows from the `BastType`'s source.
+fn dummy_field_for<'d>(ty: &BastType<'d>) -> BastField<'d> {
+    let source = ty_source(ty);
+    BastField::synthetic(ty.clone(), source)
+}
+
+fn ty_source<'d>(ty: &BastType<'d>) -> &'d serde_json::Value {
+    match ty {
+        BastType::Struct(s) => s.source(),
+        BastType::Union(u) => u.source(),
+        BastType::Array(a) => a.source(),
+        BastType::Record(r) => r.source(),
+        _ => &serde_json::Value::Null,
+    }
 }
 
 #[cfg(test)]
@@ -598,391 +562,395 @@ mod tests {
     use super::*;
     use serde_json::json;
 
-    fn materialize_packed_strict(
-        buffer: &[u8],
-        schema: &Value,
-        endian: Endian,
-    ) -> Result<Value, AlkTypeError> {
-        materialize_packed(buffer, schema, endian)
+    fn doc_from<'a>(root: &'a Value, name: &'a str) -> BastDoc<'a> {
+        BastDoc::new(root, name).expect("bast doc")
     }
 
-    // -----------------------------------------------------------------
-    // Bytes materialization (array-of-u8 form, OQ-007 resolution)
-    // -----------------------------------------------------------------
+    fn materialize_packed_strict(
+        doc: &BastDoc<'_>,
+        buffer: &[u8],
+        endian: Endian,
+    ) -> Result<Value, AlkTypeError> {
+        materialize_packed(doc, buffer, endian)
+    }
 
     #[test]
     fn materialize_bytes_packed_returns_array_of_u8() {
-        // Schema: Struct { blob: Bytes }. Wire: [len:u32 LE = 3][0x41 0x42 0xC3]
-        // 0xC3 is invalid UTF-8 lead byte — under the old from_utf8_lossy
-        // path this would corrupt. Under array-of-u8 it round-trips.
-        let schema = json!({
-            "AlkType:Struct": true,
-            "properties": {
-                "blob": { "AlkType:Bytes": true }
+        let root = json!({
+            "$defs": {
+                "S": {
+                    "kind": "struct",
+                    "fields": [ { "name": "blob", "kind": "bytes" } ]
+                }
             }
         });
+        let doc = doc_from(&root, "S");
         let mut buf = vec![0u8; 7];
         buf[0..4].copy_from_slice(&3u32.to_le_bytes());
         buf[4] = 0x41;
         buf[5] = 0x42;
         buf[6] = 0xC3;
-        let v = materialize_packed_strict(&buf, &schema, Endian::Little).expect("materialize");
-        assert_eq!(
-            v["blob"],
-            json!([65, 66, 195]),
-            "bytes should materialize as array of u8"
-        );
+        let v = materialize_packed_strict(&doc, &buf, Endian::Little).expect("materialize");
+        assert_eq!(v["blob"], json!([65, 66, 195]));
     }
 
     #[test]
     fn materialize_bytes_packed_non_utf8_round_trips() {
-        // All-non-UTF-8 bytes — would have been corrupted by from_utf8_lossy.
-        let schema = json!({
-            "AlkType:Struct": true,
-            "properties": {
-                "raw": { "AlkType:Bytes": true }
+        let root = json!({
+            "$defs": {
+                "S": {
+                    "kind": "struct",
+                    "fields": [ { "name": "raw", "kind": "bytes" } ]
+                }
             }
         });
+        let doc = doc_from(&root, "S");
         let mut buf = vec![0u8; 8];
         buf[0..4].copy_from_slice(&4u32.to_le_bytes());
         buf[4] = 0xFF;
         buf[5] = 0xFE;
         buf[6] = 0x00;
         buf[7] = 0x80;
-        let v = materialize_packed_strict(&buf, &schema, Endian::Little).expect("materialize");
+        let v = materialize_packed_strict(&doc, &buf, Endian::Little).expect("materialize");
         assert_eq!(v["raw"], json!([255, 254, 0, 128]));
     }
 
-    // -----------------------------------------------------------------
-    // Record materialization
-    // -----------------------------------------------------------------
-
     #[test]
     fn materialize_record_packed_count_prefixed_pairs() {
-        // Schema: Struct { counts: Record<Uint32> }.
-        // Wire: [count:u32=2][key_len:u32=1][b][value:u32=10][key_len:u32=1][a][value:u32=20]
-        let schema = json!({
-            "AlkType:Struct": true,
-            "properties": {
-                "counts": {
-                    "AlkType:Record": true,
-                    "values": { "AlkType:Uint32": true }
+        let root = json!({
+            "$defs": {
+                "S": {
+                    "kind": "struct",
+                    "fields": [
+                        { "name": "counts", "kind": { "kind": "record", "values": "uint32" } }
+                    ]
                 }
             }
         });
+        let doc = doc_from(&root, "S");
         let mut buf = vec![0u8; 22];
         let mut off = 0usize;
-        // count = 2
         buf[off..off + 4].copy_from_slice(&2u32.to_le_bytes());
         off += 4;
-        // key 1: "b" (len=1)
         buf[off..off + 4].copy_from_slice(&1u32.to_le_bytes());
         off += 4;
         buf[off] = b'b';
         off += 1;
-        // value 1: 10
         buf[off..off + 4].copy_from_slice(&10u32.to_le_bytes());
         off += 4;
-        // key 2: "a" (len=1)
         buf[off..off + 4].copy_from_slice(&1u32.to_le_bytes());
         off += 4;
         buf[off] = b'a';
         off += 1;
-        // value 2: 20
         buf[off..off + 4].copy_from_slice(&20u32.to_le_bytes());
-        let v = materialize_packed_strict(&buf, &schema, Endian::Little).expect("materialize");
-        assert_eq!(
-            v["counts"],
-            json!({ "b": 10, "a": 20 }),
-            "record should materialize as an object"
-        );
+        let v = materialize_packed_strict(&doc, &buf, Endian::Little).expect("materialize");
+        assert_eq!(v["counts"], json!({ "b": 10, "a": 20 }));
     }
 
     #[test]
     fn materialize_record_packed_zero_entries() {
-        let schema = json!({
-            "AlkType:Struct": true,
-            "properties": {
-                "counts": {
-                    "AlkType:Record": true,
-                    "values": { "AlkType:Uint32": true }
+        let root = json!({
+            "$defs": {
+                "S": {
+                    "kind": "struct",
+                    "fields": [
+                        { "name": "counts", "kind": { "kind": "record", "values": "uint32" } }
+                    ]
                 }
             }
         });
+        let doc = doc_from(&root, "S");
         let mut buf = vec![0u8; 4];
         buf[0..4].copy_from_slice(&0u32.to_le_bytes());
-        let v = materialize_packed_strict(&buf, &schema, Endian::Little).expect("materialize");
+        let v = materialize_packed_strict(&doc, &buf, Endian::Little).expect("materialize");
         assert_eq!(v["counts"], json!({}));
     }
 
     #[test]
     fn materialize_record_packed_rejects_short_buffer() {
-        let schema = json!({
-            "AlkType:Struct": true,
-            "properties": {
-                "counts": {
-                    "AlkType:Record": true,
-                    "values": { "AlkType:Uint32": true }
+        let root = json!({
+            "$defs": {
+                "S": {
+                    "kind": "struct",
+                    "fields": [
+                        { "name": "counts", "kind": { "kind": "record", "values": "uint32" } }
+                    ]
                 }
             }
         });
-        // Buffer too short for the count prefix.
+        let doc = doc_from(&root, "S");
         let buf = [0u8; 2];
-        let err = materialize_packed_strict(&buf, &schema, Endian::Little).unwrap_err();
+        let err = materialize_packed_strict(&doc, &buf, Endian::Little).unwrap_err();
         assert!(matches!(err, AlkTypeError::Access { .. }), "got {err:?}");
     }
 
-    // -----------------------------------------------------------------
-    // Union materialization — byte-offset and field-name shape parity (OQ-005)
-    // -----------------------------------------------------------------
-
     #[test]
     fn materialize_union_byte_discriminator_packs_variant_fields() {
-        // Schema: Struct { payload: Union(byte, offset=0, Uint8) mapping { 5 -> Read } }
-        // Read: Struct { id: Uint32 }
-        // Wire: [disc:u8=5][id:u32=42 LE]
-        let schema = json!({
-            "AlkType:Struct": true,
-            "properties": {
-                "payload": {
-                    "AlkType:Union": true,
-                    "discriminator": { "kind": "byte", "offset": 0, "type": "AlkType:Uint8" },
-                    "mapping": {
-                        "5": {
-                            "AlkType:Struct": true,
-                            "properties": { "id": { "AlkType:Uint32": true } }
+        let root = json!({
+            "$defs": {
+                "S": {
+                    "kind": "struct",
+                    "fields": [
+                        {
+                            "name": "payload",
+                            "kind": { "$ref": "#/$defs/Packet" }
                         }
+                    ]
+                },
+                "Packet": {
+                    "kind": "union",
+                    "discriminator": { "kind": "byte", "offset": 0, "type": "uint8" },
+                    "mapping": {
+                        "5": { "$ref": "#/$defs/Read" }
                     }
+                },
+                "Read": {
+                    "kind": "struct",
+                    "fields": [ { "name": "id", "kind": "uint32" } ]
                 }
             }
         });
+        let doc = doc_from(&root, "S");
         let mut buf = vec![0u8; 5];
         buf[0] = 5;
         buf[1..5].copy_from_slice(&42u32.to_le_bytes());
-        let v = materialize_packed_strict(&buf, &schema, Endian::Little).expect("materialize");
+        let v = materialize_packed_strict(&doc, &buf, Endian::Little).expect("materialize");
         let payload = &v["payload"];
-        assert_eq!(
-            payload["__discriminator"],
-            json!(5),
-            "byte-offset union should carry __discriminator"
-        );
-        assert_eq!(
-            payload["id"],
-            json!(42),
-            "variant fields should be flattened into the union object"
-        );
+        assert_eq!(payload["__discriminator"], json!(5));
+        assert_eq!(payload["id"], json!(42));
     }
 
     #[test]
     fn materialize_union_field_discriminator_includes_typed_disc_value() {
-        // Schema: Struct { payload: Union(field, name="type") mapping { "read" -> Read } }
-        // The union is a struct: [type: String "read"][variant struct].
-        // Read: Struct { n: Uint32 }
-        // Wire: [len:u32=4][read][n:u32=7 LE]
-        let schema = json!({
-            "AlkType:Struct": true,
-            "properties": {
-                "payload": {
-                    "AlkType:Union": true,
-                    "discriminator": { "kind": "field", "name": "type" },
-                    "properties": {
-                        "type": { "AlkType:String": true }
-                    },
-                    "mapping": {
-                        "read": {
-                            "AlkType:Struct": true,
-                            "properties": { "n": { "AlkType:Uint32": true } }
+        let root = json!({
+            "$defs": {
+                "S": {
+                    "kind": "struct",
+                    "fields": [
+                        {
+                            "name": "payload",
+                            "kind": { "$ref": "#/$defs/Event" }
                         }
+                    ]
+                },
+                "Event": {
+                    "kind": "union",
+                    "discriminator": { "kind": "field", "name": "type" },
+                    "fields": [ { "name": "type", "kind": "string" } ],
+                    "mapping": {
+                        "read": { "$ref": "#/$defs/Read" }
                     }
+                },
+                "Read": {
+                    "kind": "struct",
+                    "fields": [ { "name": "n", "kind": "uint32" } ]
                 }
             }
         });
+        let doc = doc_from(&root, "S");
         let mut buf = vec![0u8; 12];
         buf[0..4].copy_from_slice(&4u32.to_le_bytes());
         buf[4..8].copy_from_slice(b"read");
         buf[8..12].copy_from_slice(&7u32.to_le_bytes());
-        let v = materialize_packed_strict(&buf, &schema, Endian::Little).expect("materialize");
+        let v = materialize_packed_strict(&doc, &buf, Endian::Little).expect("materialize");
         let payload = &v["payload"];
-        // __discriminator carries the mapping key (string).
         assert_eq!(payload["__discriminator"], json!("read"));
-        // The original typed discriminator value is preserved under its field name.
         assert_eq!(payload["type"], json!("read"));
-        // Variant fields are flattened.
         assert_eq!(payload["n"], json!(7));
     }
 
     #[test]
     fn materialize_union_field_discriminator_advances_offset_correctly() {
-        // Regression: the old field-name path returned the start offset,
-        // not the end. A struct with a union followed by another field
-        // would read the second field from the wrong position. This test
-        // places a Uint32 after the union and verifies it reads correctly.
-        let schema = json!({
-            "AlkType:Struct": true,
-            "properties": {
-                "payload": {
-                    "AlkType:Union": true,
+        let root = json!({
+            "$defs": {
+                "S": {
+                    "kind": "struct",
+                    "fields": [
+                        {
+                            "name": "payload",
+                            "kind": { "$ref": "#/$defs/Event" }
+                        },
+                        { "name": "trailer", "kind": "uint32" }
+                    ]
+                },
+                "Event": {
+                    "kind": "union",
                     "discriminator": { "kind": "field", "name": "type" },
-                    "properties": {
-                        "type": { "AlkType:String": true }
-                    },
+                    "fields": [ { "name": "type", "kind": "string" } ],
                     "mapping": {
-                        "read": {
-                            "AlkType:Struct": true,
-                            "properties": { "n": { "AlkType:Uint32": true } }
-                        }
+                        "read": { "$ref": "#/$defs/Read" }
                     }
                 },
-                "trailer": { "AlkType:Uint32": true }
+                "Read": {
+                    "kind": "struct",
+                    "fields": [ { "name": "n", "kind": "uint32" } ]
+                }
             }
         });
-        // Wire: [len:u32=4]["read"][n:u32=7][trailer:u32=99]
+        let doc = doc_from(&root, "S");
         let mut buf = vec![0u8; 16];
         buf[0..4].copy_from_slice(&4u32.to_le_bytes());
         buf[4..8].copy_from_slice(b"read");
         buf[8..12].copy_from_slice(&7u32.to_le_bytes());
         buf[12..16].copy_from_slice(&99u32.to_le_bytes());
-        let v = materialize_packed_strict(&buf, &schema, Endian::Little).expect("materialize");
-        assert_eq!(v["trailer"], json!(99), "trailer should read from after the union");
+        let v = materialize_packed_strict(&doc, &buf, Endian::Little).expect("materialize");
+        assert_eq!(v["trailer"], json!(99));
         assert_eq!(v["payload"]["n"], json!(7));
     }
 
     #[test]
     fn materialize_union_byte_discriminator_unknown_value_is_access_error() {
-        let schema = json!({
-            "AlkType:Struct": true,
-            "properties": {
-                "payload": {
-                    "AlkType:Union": true,
-                    "discriminator": { "kind": "byte", "offset": 0, "type": "AlkType:Uint8" },
-                    "mapping": { "5": { "AlkType:Struct": true, "properties": {} } }
-                }
-            }
-        });
-        let buf = [99u8];
-        let err = materialize_packed_strict(&buf, &schema, Endian::Little).unwrap_err();
-        assert!(matches!(err, AlkTypeError::Access { .. }), "got {err:?}");
-    }
-
-    // -----------------------------------------------------------------
-    // $ref resolution (root-schema threading)
-    // -----------------------------------------------------------------
-
-    #[test]
-    fn materialize_union_with_ref_variant_resolves_via_root() {
-        // The SFTP shape: struct wrapping a union whose variants are $refs
-        // into $defs. The materializer must resolve the $ref against the
-        // root schema to find the variant's AlkType:Struct kind.
-        let schema = json!({
-            "AlkType:Struct": true,
-            "properties": {
-                "payload": {
-                    "AlkType:Union": true,
-                    "discriminator": { "kind": "byte", "offset": 0, "type": "AlkType:Uint8" },
+        let root = json!({
+            "$defs": {
+                "S": {
+                    "kind": "struct",
+                    "fields": [
+                        {
+                            "name": "payload",
+                            "kind": { "$ref": "#/$defs/Packet" }
+                        }
+                    ]
+                },
+                "Packet": {
+                    "kind": "union",
+                    "discriminator": { "kind": "byte", "offset": 0, "type": "uint8" },
                     "mapping": {
                         "5": { "$ref": "#/$defs/Read" }
                     }
-                }
-            },
-            "$defs": {
+                },
                 "Read": {
-                    "AlkType:Struct": true,
-                    "properties": { "id": { "AlkType:Uint32": true } }
+                    "kind": "struct",
+                    "fields": []
                 }
             }
         });
+        let doc = doc_from(&root, "S");
+        let buf = [99u8];
+        let err = materialize_packed_strict(&doc, &buf, Endian::Little).unwrap_err();
+        assert!(matches!(err, AlkTypeError::Access { .. }), "got {err:?}");
+    }
+
+    #[test]
+    fn materialize_union_with_ref_variant_resolves_via_root() {
+        let root = json!({
+            "$defs": {
+                "S": {
+                    "kind": "struct",
+                    "fields": [
+                        {
+                            "name": "payload",
+                            "kind": { "$ref": "#/$defs/Packet" }
+                        }
+                    ]
+                },
+                "Packet": {
+                    "kind": "union",
+                    "discriminator": { "kind": "byte", "offset": 0, "type": "uint8" },
+                    "mapping": {
+                        "5": { "$ref": "#/$defs/Read" }
+                    }
+                },
+                "Read": {
+                    "kind": "struct",
+                    "fields": [ { "name": "id", "kind": "uint32" } ]
+                }
+            }
+        });
+        let doc = doc_from(&root, "S");
         let mut buf = vec![0u8; 5];
         buf[0] = 5;
         buf[1..5].copy_from_slice(&42u32.to_le_bytes());
-        let v = materialize_packed_strict(&buf, &schema, Endian::Little).expect("materialize");
+        let v = materialize_packed_strict(&doc, &buf, Endian::Little).expect("materialize");
         assert_eq!(v["payload"]["__discriminator"], json!(5));
         assert_eq!(v["payload"]["id"], json!(42));
     }
 
     #[test]
     fn materialize_array_with_ref_element_resolves_via_root() {
-        let schema = json!({
-            "AlkType:Struct": true,
-            "properties": {
-                "items": {
-                    "AlkType:Array": true,
-                    "minItems": 2,
-                    "maxItems": 2,
-                    "items": { "$ref": "#/$defs/Point" }
-                }
-            },
+        let root = json!({
             "$defs": {
+                "S": {
+                    "kind": "struct",
+                    "fields": [
+                        {
+                            "name": "items",
+                            "kind": {
+                                "kind": "array",
+                                "element": { "$ref": "#/$defs/Point" },
+                                "count": 2
+                            }
+                        }
+                    ]
+                },
                 "Point": {
-                    "AlkType:Struct": true,
-                    "properties": {
-                        "x": { "AlkType:Uint16": true },
-                        "y": { "AlkType:Uint16": true }
-                    }
+                    "kind": "struct",
+                    "fields": [
+                        { "name": "x", "kind": "uint16" },
+                        { "name": "y", "kind": "uint16" }
+                    ]
                 }
             }
         });
-        // Wire: [x:u16=1 LE][y:u16=2 LE][x:u16=3 LE][y:u16=4 LE]
+        let doc = doc_from(&root, "S");
         let mut buf = vec![0u8; 8];
         buf[0..2].copy_from_slice(&1u16.to_le_bytes());
         buf[2..4].copy_from_slice(&2u16.to_le_bytes());
         buf[4..6].copy_from_slice(&3u16.to_le_bytes());
         buf[6..8].copy_from_slice(&4u16.to_le_bytes());
-        let v = materialize_packed_strict(&buf, &schema, Endian::Little).expect("materialize");
-        assert_eq!(
-            v["items"],
-            json!([
-                { "x": 1, "y": 2 },
-                { "x": 3, "y": 4 }
-            ])
-        );
+        let v = materialize_packed_strict(&doc, &buf, Endian::Little).expect("materialize");
+        assert_eq!(v["items"], json!([{ "x": 1, "y": 2 }, { "x": 3, "y": 4 }]));
     }
 
-    // -----------------------------------------------------------------
-    // Smoke: a struct field after a nested struct advances correctly
-    // -----------------------------------------------------------------
-
     #[test]
     fn materialize_struct_with_nested_struct_then_field() {
-        let schema = json!({
-            "AlkType:Struct": true,
-            "properties": {
-                "header": {
-                    "AlkType:Struct": true,
-                    "properties": {
-                        "a": { "AlkType:Uint8": true },
-                        "b": { "AlkType:Uint8": true }
-                    }
-                },
-                "after": { "AlkType:Uint32": true }
+        let root = json!({
+            "$defs": {
+                "S": {
+                    "kind": "struct",
+                    "fields": [
+                        {
+                            "name": "header",
+                            "kind": {
+                                "kind": "struct",
+                                "fields": [
+                                    { "name": "a", "kind": "uint8" },
+                                    { "name": "b", "kind": "uint8" }
+                                ]
+                            }
+                        },
+                        { "name": "after", "kind": "uint32" }
+                    ]
+                }
             }
         });
-        // Wire: [a=1][b=2][after=0x03030303 LE = 50529027]
+        let doc = doc_from(&root, "S");
         let mut buf = vec![0u8; 6];
         buf[0] = 1;
         buf[1] = 2;
         buf[2..6].copy_from_slice(&0x03030303u32.to_le_bytes());
-        let v = materialize_packed_strict(&buf, &schema, Endian::Little).expect("materialize");
+        let v = materialize_packed_strict(&doc, &buf, Endian::Little).expect("materialize");
         assert_eq!(v["header"]["a"], json!(1));
         assert_eq!(v["header"]["b"], json!(2));
         assert_eq!(v["after"], json!(0x03030303u32));
     }
 
-    // -----------------------------------------------------------------
-    // Sanity: existing packed chunk-header path still works
-    // -----------------------------------------------------------------
-
     #[test]
     fn materialize_chunk_header_packed() {
-        let schema = json!({
-            "AlkType:Struct": true,
-            "endian": "big",
-            "properties": {
-                "channel_id": { "AlkType:Uint32": true },
-                "length":     { "AlkType:Uint32": true }
+        let root = json!({
+            "$defs": {
+                "S": {
+                    "kind": "struct",
+                    "endian": "big",
+                    "fields": [
+                        { "name": "channel_id", "kind": "uint32" },
+                        { "name": "length",     "kind": "uint32" }
+                    ]
+                }
             }
         });
+        let doc = doc_from(&root, "S");
         let buf = [0u8, 0u8, 0u8, 42u8, 0u8, 0u8, 0u8, 7u8];
-        let v = materialize_packed_strict(&buf, &schema, Endian::Big).expect("materialize");
+        let v = materialize_packed_strict(&doc, &buf, Endian::Big).expect("materialize");
         assert_eq!(v["channel_id"], json!(42));
         assert_eq!(v["length"], json!(7));
     }
diff --git a/src/offset_map.rs b/src/offset_map.rs
index a39b53c..962520f 100644
--- a/src/offset_map.rs
+++ b/src/offset_map.rs
@@ -5,18 +5,18 @@
 //! the variable data is not included in the static layout. Used for
 //! mmap-friendly formats (metatensor, safetensors).
 //!
-//! The offset computation is a recursive walk of the schema JSON. Nested
-//! structs propagate field path prefixes (producing dotted paths like
-//! `"header.version"`). Alignment padding is inserted before each field
-//! to satisfy the field's alignment requirement (natural alignment by
-//! default, overridable via the `"align"` annotation).
+//! The offset computation is a recursive walk of the BAST typed tree
+//! ([`crate::bast::BastDoc`]). Nested structs propagate field path
+//! prefixes (producing dotted paths like `"header.version"`). Alignment
+//! padding is inserted before each field to satisfy the field's alignment
+//! requirement (natural alignment by default, overridable via the
+//! `"align"` annotation).
 
-use crate::error::AlkTypeError;
-use crate::schema::{
-    get_alktype_kind, get_alktype_kind_loose_enum, parse_align, parse_encoding,
-    parse_max_length, resolve_ref_or_inline, AlkTypeKind, VariableEncoding,
+use crate::bast::{
+    BastArray, BastDefKind, BastDoc, BastField, BastStruct, BastType,
 };
-use serde_json::Value;
+use crate::error::AlkTypeError;
+use crate::schema::{AlkTypeKind, VariableEncoding};
 
 /// A byte range within a buffer.
 ///
@@ -45,7 +45,8 @@ impl ByteRange {
     }
 }
 
-/// A flat table of `(field_path, byte_range)` pairs computed from a schema.
+/// A flat table of `(field_path, byte_range)` pairs computed from a BAST
+/// document.
 ///
 /// Fields have fixed positions with natural alignment padding.
 /// Used for mmap-friendly formats (metatensor, safetensors) where random
@@ -63,37 +64,36 @@ pub struct OffsetMap {
 }
 
 impl OffsetMap {
-    /// Compute the offset map from a schema JSON value.
+    /// Compute the offset map from a BAST document.
     ///
-    /// Walks the schema recursively, computing byte positions for each
-    /// field based on type sizes, field order, and alignment. The
-    /// top-level schema must be a `AlkType:Struct`.
+    /// Walks the BAST typed tree recursively, computing byte positions
+    /// for each field based on type sizes, field order, and alignment.
+    /// The root type must be a struct.
     ///
     /// # Errors
     ///
-    /// Returns [`AlkTypeError::Schema`] if the top-level schema is not a
-    /// `AlkType:Struct` or has no `AlkType:*` kind, or if the schema is
-    /// malformed (missing `properties`, unknown kind, etc.).
-    ///
+    /// Returns [`AlkTypeError::Schema`] if the root type is not a struct.
     /// Returns [`AlkTypeError::Offset`] for unsupported type combinations
-    /// encountered during the walk.
-    pub fn compute(schema: &Value) -> Result<Self, AlkTypeError> {
-        let kind = get_alktype_kind(schema)
-            .and_then(|s| s.parse::<AlkTypeKind>().ok())
-            .ok_or_else(|| {
-                AlkTypeError::Schema("top-level schema has no AlkType:* kind".to_string())
-            })?;
-        if kind != AlkTypeKind::Struct {
-            return Err(AlkTypeError::Schema(format!(
-                "OffsetMap::compute requires a AlkType:Struct at the top level, got {kind}"
-            )));
-        }
+    /// encountered during the walk (e.g. unions, which are rejected in
+    /// aligned mode per ADR-008).
+    pub fn compute<'a>(doc: &'a BastDoc<'a>) -> Result<Self, AlkTypeError> {
+        let root_def = doc.root_def();
+        let struct_node = match root_def.kind() {
+            BastDefKind::Struct(s) => s,
+            other => {
+                return Err(AlkTypeError::Schema(format!(
+                    "OffsetMap::compute requires a struct at the root, got {kind}",
+                    kind = other.alk_kind()
+                )));
+            }
+        };
         let mut ctx = ComputeCtx {
-            root: schema,
+            doc,
             fields: Vec::new(),
             offset: 0,
         };
-        let (total, _align) = ctx.compute_struct(schema, "", 1)?;
+        let struct_default_align = struct_node.align().unwrap_or(1).max(1);
+        let (total, _align) = ctx.compute_struct(struct_node, "", struct_default_align)?;
         Ok(Self {
             fields: ctx.fields,
             total_size: total,
@@ -120,9 +120,8 @@ impl OffsetMap {
 
     /// Iterate over all `(field_path, byte_range)` pairs in insertion order.
     ///
-    /// Field order matches the schema's `properties` order (preserved by
-    /// `serde_json`'s `preserve_order` feature). Nested struct fields
-    /// appear after their parent's path prefix.
+    /// Field order matches the BAST `fields` array order. Nested struct
+    /// fields appear after their parent's path prefix.
     pub fn iter(&self) -> impl Iterator<Item = &(String, ByteRange)> {
         self.fields.iter()
     }
@@ -131,10 +130,10 @@ impl OffsetMap {
 /// Mutable context threaded through the recursive offset computation.
 ///
 /// Carries the running `offset`, the accumulating `fields` vec, and a
-/// reference to the root schema for `$ref` resolution. Grouping these
+/// reference to the BAST doc for `$ref` resolution. Grouping these
 /// keeps the recursive helper signatures small.
-struct ComputeCtx<'a> {
-    root: &'a Value,
+struct ComputeCtx<'d> {
+    doc: &'d BastDoc<'d>,
     fields: Vec<(String, ByteRange)>,
     offset: usize,
 }
@@ -144,8 +143,8 @@ struct FieldLayout {
     align: usize,
 }
 
-impl<'a> ComputeCtx<'a> {
-    /// Recurse into a `AlkType:Struct`, appending `(field_path, ByteRange)`
+impl<'d> ComputeCtx<'d> {
+    /// Recurse into a `BastStruct`, appending `(field_path, ByteRange)`
     /// pairs to `self.fields` and advancing `self.offset`.
     ///
     /// Returns `(total_size, alignment)` where `total_size` includes
@@ -153,85 +152,55 @@ impl<'a> ComputeCtx<'a> {
     /// effective alignment (its own `align` annotation, or the max of its
     /// fields' alignments).
     ///
-    /// `struct_schema` is the schema of the struct to walk. `prefix` is the
-    /// dotted path prefix for nested fields (empty at the top level).
-    /// `parent_struct_align` is the default alignment a field inherits
-    /// when it specifies neither its own `align` annotation nor a natural
-    /// alignment larger than the default.
+    /// `prefix` is the dotted path prefix for nested fields (empty at the
+    /// top level). `parent_struct_align` is the default alignment a field
+    /// inherits when it specifies neither its own `align` annotation nor
+    /// a natural alignment larger than the default.
     fn compute_struct(
         &mut self,
-        struct_schema: &Value,
+        struct_node: &BastStruct<'d>,
         prefix: &str,
         parent_struct_align: usize,
     ) -> Result<(usize, usize), AlkTypeError> {
-        let obj = struct_schema
-            .as_object()
-            .ok_or_else(|| AlkTypeError::Schema("struct schema is not an object".to_string()))?;
-        let properties = obj
-            .get("properties")
-            .and_then(|v| v.as_object())
-            .ok_or_else(|| {
-                AlkTypeError::Schema("struct schema has no 'properties' object".to_string())
-            })?;
-
-        let struct_default_align = parse_align(struct_schema).unwrap_or(parent_struct_align);
+        let struct_default_align = struct_node.align().unwrap_or(parent_struct_align).max(1);
         let mut max_align: usize = 1;
         let struct_start = self.offset;
-
-        let field_schemas: Vec<(String, Value)> = properties
-            .iter()
-            .map(|(k, v)| (k.clone(), v.clone()))
-            .collect();
-        let field_count = field_schemas.len();
-        for (i, (field_name, field_schema)) in field_schemas.iter().enumerate() {
+        let fields = struct_node.fields();
+        let field_count = fields.len();
+        for (i, field) in fields.iter().enumerate() {
             let field_path = if prefix.is_empty() {
-                field_name.clone()
+                field.name().to_string()
             } else {
-                format!("{prefix}.{field_name}")
+                format!("{prefix}.{}", field.name())
             };
-            // ADR-100: reject non-final inline length-prefixed variable fields.
-            // The OffsetMap reserves only 4 bytes (the length prefix), but
-            // data_access::write_string writes prefix+data inline — clobbering
-            // subsequent fields. Only allowed as the last field in the struct.
             if i < field_count - 1 {
-                if let Some(kind) = get_alktype_kind_loose_enum(field_schema) {
-                    if kind.is_variable_length() {
-                        let keyword_value = field_schema
-                            .as_object()
-                            .and_then(|o| {
-                                o.keys()
-                                    .find(|k| k.starts_with("AlkType:"))
-                                    .and_then(|k| o.get(k))
-                            })
-                            .cloned()
-                            .unwrap_or(Value::Bool(true));
-                        let encoding = parse_encoding(&keyword_value);
-                        let max_length = parse_max_length(field_schema);
-                        let is_inline_length_prefixed =
-                            encoding == VariableEncoding::LengthPrefixed && max_length.is_none();
-                        if is_inline_length_prefixed {
-                            return Err(AlkTypeError::Offset {
-                                field_path: field_path.clone(),
-                                reason: format!(
-                                    "non-final inline length-prefixed variable field \
-                                     ({kind}) in aligned mode: the variable data would \
-                                     clobber subsequent fields. Use `maxLength` \
-                                     (fixed-size reservation) or \
-                                     `\"encoding\": \"offset-indirect\"`, or move this \
-                                     field to the last position in the struct. (ADR-100)"
-                                ),
-                            });
-                        }
+                if let Some(kind) = field_variable_kind(field) {
+                    let encoding = field.encoding();
+                    let max_length = field.max_length();
+                    let is_inline_length_prefixed =
+                        encoding == VariableEncoding::LengthPrefixed && max_length.is_none();
+                    if is_inline_length_prefixed {
+                        return Err(AlkTypeError::Offset {
+                            field_path: field_path.clone(),
+                            reason: format!(
+                                "non-final inline length-prefixed variable field \
+                                 ({kind}) in aligned mode: the variable data would \
+                                 clobber subsequent fields. Use `maxLength` \
+                                 (fixed-size reservation) or \
+                                 `\"encoding\": \"offset-indirect\"`, or move this \
+                                 field to the last position in the struct. (ADR-006)"
+                            ),
+                        });
                     }
                 }
             }
-            let layout = self.compute_field(field_schema, &field_path, struct_default_align)?;
+            let layout = self.compute_field(field, &field_path, struct_default_align)?;
             if layout.align > max_align {
                 max_align = layout.align;
             }
         }
 
-        let effective_align = parse_align(struct_schema).unwrap_or(max_align).max(1);
+        let effective_align = struct_node.align().unwrap_or(max_align).max(1);
         align_up(&mut self.offset, effective_align);
         let total = self.offset - struct_start;
         Ok((total, effective_align))
@@ -241,42 +210,41 @@ impl<'a> ComputeCtx<'a> {
     /// and appending any field paths to `self.fields`.
     fn compute_field(
         &mut self,
-        field_schema: &Value,
+        field: &BastField<'d>,
         field_path: &str,
         struct_default_align: usize,
     ) -> Result<FieldLayout, AlkTypeError> {
-        let kind = get_alktype_kind_loose_enum(field_schema).ok_or_else(|| AlkTypeError::Offset {
-            field_path: field_path.to_string(),
-            reason: "field schema has no AlkType:* kind".to_string(),
-        })?;
-
-        match kind {
-            AlkTypeKind::Struct => {
-                self.compute_struct_field(field_schema, field_path, struct_default_align)
-            }
-            AlkTypeKind::Union => Err(AlkTypeError::Offset {
+        let ty = field.ty();
+        let resolved = self.doc.resolve_typeref(ty)?;
+        match &resolved {
+            BastType::Struct(s) => self.compute_struct_field(s, field, field_path, struct_default_align),
+            BastType::Union(_) => Err(AlkTypeError::Offset {
                 field_path: field_path.to_string(),
-                reason: "TUnion is not supported in aligned static mode (ADR-102). \
+                reason: "TUnion is not supported in aligned static mode (ADR-008). \
                          Unions are the protocol dispatch pattern — use packed sequential \
                          mode (LayoutMode::Packed) for TUnion fields, or restructure as \
                          a struct with an explicit discriminator field."
                     .to_string(),
             }),
-            AlkTypeKind::Array => {
-                self.compute_array_field(field_schema, field_path, struct_default_align)
+            BastType::Array(a) => self.compute_array_field(a, field, field_path, struct_default_align),
+            BastType::Record(_) => {
+                self.compute_variable_field(field, field_path, struct_default_align)
             }
-            AlkTypeKind::String
-            | AlkTypeKind::Bytes
-            | AlkTypeKind::Record
-            | AlkTypeKind::Timestamp => {
-                self.compute_variable_field(field_schema, field_path, struct_default_align)
+            BastType::Primitive(k) if k.is_variable_length() => {
+                self.compute_variable_field(field, field_path, struct_default_align)
             }
-            k if k.is_fixed_size() => {
-                self.compute_fixed_field(k, field_schema, field_path, struct_default_align)
+            BastType::Primitive(k) => {
+                self.compute_fixed_field(*k, field, field_path, struct_default_align)
             }
-            other => Err(AlkTypeError::Offset {
+            BastType::Enum(_) => self.compute_fixed_field(
+                AlkTypeKind::Enum,
+                field,
+                field_path,
+                struct_default_align,
+            ),
+            BastType::Ref(_) => Err(AlkTypeError::Offset {
                 field_path: field_path.to_string(),
-                reason: format!("unsupported AlkType kind {other} for aligned offset computation"),
+                reason: "internal: resolve_typeref returned a Ref".to_string(),
             }),
         }
     }
@@ -285,7 +253,7 @@ impl<'a> ComputeCtx<'a> {
     fn compute_fixed_field(
         &mut self,
         kind: AlkTypeKind,
-        field_schema: &Value,
+        field: &BastField<'d>,
         field_path: &str,
         struct_default_align: usize,
     ) -> Result<FieldLayout, AlkTypeError> {
@@ -294,35 +262,42 @@ impl<'a> ComputeCtx<'a> {
             reason: format!("type_size returned None for fixed kind {kind}"),
         })?;
         let natural = kind.natural_alignment();
-        let align = field_alignment(field_schema, struct_default_align, natural);
+        let align = field_alignment(field, struct_default_align, natural);
         align_up(&mut self.offset, align);
         let start = self.offset;
-        self.offset += size;
+        self.offset = start
+            .checked_add(size)
+            .ok_or_else(|| AlkTypeError::Offset {
+                field_path: field_path.to_string(),
+                reason: format!("offset {start} + size {size} overflows usize"),
+            })?;
         self.push(field_path, start, start + size);
         Ok(FieldLayout { align })
     }
 
-    /// Compute the layout for a nested `AlkType:Struct` field.
+    /// Compute the layout for a nested struct field.
     ///
     /// Probes the nested struct's layout at a temporary offset of 0 to
     /// determine its total size and alignment, aligns the parent offset,
     /// then shifts the nested fields to their final positions.
     fn compute_struct_field(
         &mut self,
-        field_schema: &Value,
+        struct_node: &BastStruct<'d>,
+        field: &BastField<'d>,
         field_path: &str,
         struct_default_align: usize,
     ) -> Result<FieldLayout, AlkTypeError> {
-        let inner_parent_align = parse_align(field_schema).unwrap_or(struct_default_align);
+        let inner_parent_align = field.align().unwrap_or(struct_default_align);
         let mut probe = ComputeCtx {
-            root: self.root,
+            doc: self.doc,
             fields: Vec::new(),
             offset: 0,
         };
         let (inner_total, inner_align) =
-            probe.compute_struct(field_schema, field_path, inner_parent_align)?;
+            probe.compute_struct(struct_node, field_path, inner_parent_align)?;
 
-        let align = field_alignment(field_schema, struct_default_align, inner_align);
+        let natural = inner_align;
+        let align = field_alignment(field, struct_default_align, natural);
         align_up(&mut self.offset, align);
         let struct_start = self.offset;
         for (path, range) in probe.fields {
@@ -334,44 +309,31 @@ impl<'a> ComputeCtx<'a> {
                 },
             ));
         }
-        self.offset = struct_start + inner_total;
+        self.offset = struct_start
+            .checked_add(inner_total)
+            .ok_or_else(|| AlkTypeError::Offset {
+                field_path: field_path.to_string(),
+                reason: format!("struct start {struct_start} + inner total {inner_total} overflows usize"),
+            })?;
         Ok(FieldLayout { align })
     }
 
-    /// Compute the layout for a `AlkType:Array` field.
+    /// Compute the layout for a `BastArray` field.
     fn compute_array_field(
         &mut self,
-        field_schema: &Value,
+        array: &BastArray<'d>,
+        field: &BastField<'d>,
         field_path: &str,
         struct_default_align: usize,
     ) -> Result<FieldLayout, AlkTypeError> {
-        let obj = field_schema
-            .as_object()
-            .ok_or_else(|| AlkTypeError::Offset {
-                field_path: field_path.to_string(),
-                reason: "array schema is not an object".to_string(),
-            })?;
-
-        let items = obj.get("items").ok_or_else(|| AlkTypeError::Offset {
-            field_path: field_path.to_string(),
-            reason: "TArray is missing 'items'".to_string(),
-        })?;
-        let element_schema =
-            resolve_ref_or_inline(items, self.root).ok_or_else(|| AlkTypeError::Offset {
-                field_path: field_path.to_string(),
-                reason: "could not resolve TArray items schema".to_string(),
-            })?;
-        let elem_kind = get_alktype_kind(element_schema)
-            .and_then(|s| s.parse::<AlkTypeKind>().ok())
-            .ok_or_else(|| AlkTypeError::Offset {
-                field_path: field_path.to_string(),
-                reason: "TArray element schema has no AlkType:* kind".to_string(),
-            })?;
+        let element_ty = array.element();
+        let resolved_elem = self.doc.resolve_typeref(element_ty)?;
+        let elem_kind = resolved_elem.alk_kind();
         if !elem_kind.is_fixed_size() {
             return Err(AlkTypeError::Offset {
                 field_path: field_path.to_string(),
                 reason: format!(
-                    "TArray of variable-length element kind {elem_kind} is not supported (OQ-069)"
+                    "array of variable-length element kind {elem_kind} is not supported (OQ-001)"
                 ),
             });
         }
@@ -381,46 +343,49 @@ impl<'a> ComputeCtx<'a> {
             reason: format!("element kind {elem_kind} has no fixed size"),
         })?;
         let elem_natural = elem_kind.natural_alignment();
-        let elem_align = field_alignment(element_schema, struct_default_align, elem_natural);
+        let elem_align = element_alignment(&resolved_elem, struct_default_align, elem_natural);
         let stride = round_up(elem_size, elem_align);
+        let count = array.count();
 
-        let min_items = obj
-            .get("minItems")
-            .and_then(|v| v.as_u64())
-            .map(|n| n as usize);
-        let max_items = obj
-            .get("maxItems")
-            .and_then(|v| v.as_u64())
-            .map(|n| n as usize);
-        let fixed_count = match (min_items, max_items) {
-            (Some(mn), Some(mx)) if mn == mx => Some(mn),
-            _ => None,
-        };
+        let array_align = field_alignment(field, struct_default_align, elem_align);
 
-        let array_align = field_alignment(field_schema, struct_default_align, elem_align);
-
-        if let Some(count) = fixed_count {
-            align_up(&mut self.offset, array_align);
-            let start = self.offset;
-            for i in 0..count {
-                let elem_start = start + i * stride;
-                let elem_end = elem_start + elem_size;
-                let elem_path = format!("{field_path}[{i}]");
-                self.push(&elem_path, elem_start, elem_end);
-            }
-            let array_size = count * stride;
-            self.offset = start + array_size;
-            Ok(FieldLayout { align: array_align })
-        } else {
-            let count_prefix_align = array_align.max(4);
-            align_up(&mut self.offset, count_prefix_align);
-            let start = self.offset;
-            self.push(field_path, start, start + 4);
-            self.offset = start + 4;
-            Ok(FieldLayout {
-                align: count_prefix_align,
-            })
+        align_up(&mut self.offset, array_align);
+        let start = self.offset;
+        for i in 0..count {
+            let elem_start = start
+                .checked_add(
+                    i.checked_mul(stride)
+                        .ok_or_else(|| AlkTypeError::Offset {
+                            field_path: field_path.to_string(),
+                            reason: format!("element index {i} × stride {stride} overflows usize"),
+                        })?,
+                )
+                .ok_or_else(|| AlkTypeError::Offset {
+                    field_path: field_path.to_string(),
+                    reason: format!("element offset {start} + {i}×{stride} overflows usize"),
+                })?;
+            let elem_end = elem_start
+                .checked_add(elem_size)
+                .ok_or_else(|| AlkTypeError::Offset {
+                    field_path: field_path.to_string(),
+                    reason: format!("element end {elem_start} + {elem_size} overflows usize"),
+                })?;
+            let elem_path = format!("{field_path}[{i}]");
+            self.push(&elem_path, elem_start, elem_end);
         }
+        let array_size = count
+            .checked_mul(stride)
+            .ok_or_else(|| AlkTypeError::Offset {
+                field_path: field_path.to_string(),
+                reason: format!("array size {count} × stride {stride} overflows usize"),
+            })?;
+        self.offset = start
+            .checked_add(array_size)
+            .ok_or_else(|| AlkTypeError::Offset {
+                field_path: field_path.to_string(),
+                reason: format!("offset {start} + array size {array_size} overflows usize"),
+            })?;
+        Ok(FieldLayout { align: array_align })
     }
 
     /// Compute the layout for a variable-length field (String/Bytes/Record/Timestamp).
@@ -431,21 +396,12 @@ impl<'a> ComputeCtx<'a> {
     /// - inline length-prefixing (default): a 4-byte length prefix.
     fn compute_variable_field(
         &mut self,
-        field_schema: &Value,
+        field: &BastField<'d>,
         field_path: &str,
         struct_default_align: usize,
     ) -> Result<FieldLayout, AlkTypeError> {
-        let keyword_value = field_schema
-            .as_object()
-            .and_then(|o| {
-                o.keys()
-                    .find(|k| k.starts_with("AlkType:"))
-                    .and_then(|k| o.get(k))
-            })
-            .cloned()
-            .unwrap_or(Value::Bool(true));
-        let encoding = parse_encoding(&keyword_value);
-        let max_length = parse_max_length(field_schema);
+        let encoding = field.encoding();
+        let max_length = field.max_length();
 
         let (size, natural) = match (max_length, encoding) {
             (Some(max_len), _) => (max_len, 1),
@@ -453,10 +409,15 @@ impl<'a> ComputeCtx<'a> {
             (None, VariableEncoding::LengthPrefixed) => (4, 4),
         };
 
-        let align = field_alignment(field_schema, struct_default_align, natural);
+        let align = field_alignment(field, struct_default_align, natural);
         align_up(&mut self.offset, align);
         let start = self.offset;
-        self.offset += size;
+        self.offset = start
+            .checked_add(size)
+            .ok_or_else(|| AlkTypeError::Offset {
+                field_path: field_path.to_string(),
+                reason: format!("offset {start} + size {size} overflows usize"),
+            })?;
         self.push(field_path, start, start + size);
         Ok(FieldLayout { align })
     }
@@ -468,15 +429,41 @@ impl<'a> ComputeCtx<'a> {
     }
 }
 
+/// If the field's type is a variable-length primitive, return its kind.
+fn field_variable_kind(field: &BastField<'_>) -> Option<AlkTypeKind> {
+    match field.ty() {
+        BastType::Primitive(k) if k.is_variable_length() => Some(*k),
+        _ => None,
+    }
+}
+
 /// Resolve the field's alignment: field-level `align` annotation,
 /// then the struct default, then the natural alignment.
-fn field_alignment(field_schema: &Value, struct_default_align: usize, natural: usize) -> usize {
-    if let Some(a) = parse_align(field_schema) {
+fn field_alignment(field: &BastField<'_>, struct_default_align: usize, natural: usize) -> usize {
+    if let Some(a) = field.align() {
         return a.max(1);
     }
     struct_default_align.max(natural).max(1)
 }
 
+/// Resolve an element type's alignment. Inline struct/array elements use
+/// natural alignment 1; primitives use their natural alignment; field-level
+/// `align` from the enclosing field node doesn't apply to inline element
+/// schemas (BAST field-level annotations live on the field, not the
+/// element TypeRef), so we fall back to the struct default.
+fn element_alignment(
+    elem_ty: &BastType<'_>,
+    struct_default_align: usize,
+    natural: usize,
+) -> usize {
+    match elem_ty {
+        BastType::Struct(_) | BastType::Union(_) | BastType::Array(_) => {
+            struct_default_align.max(1)
+        }
+        _ => struct_default_align.max(natural).max(1),
+    }
+}
+
 /// Round `offset` up to the next multiple of `align`. No-op if `align <= 1`.
 fn align_up(offset: &mut usize, align: usize) {
     if align <= 1 {
@@ -506,20 +493,25 @@ mod tests {
     use super::*;
     use serde_json::json;
 
-    fn map(schema: &Value) -> OffsetMap {
-        OffsetMap::compute(schema).expect("offset map computation")
+    fn map(root: &serde_json::Value, name: &str) -> OffsetMap {
+        let doc = BastDoc::new(root, name).expect("bast doc");
+        OffsetMap::compute(&doc).expect("offset map computation")
     }
 
     #[test]
     fn simple_fixed_fields_natural_alignment() {
-        let schema = json!({
-            "AlkType:Struct": true,
-            "properties": {
-                "flag": { "AlkType:Uint8": true },
-                "id": { "AlkType:Uint32": true }
+        let root = json!({
+            "$defs": {
+                "S": {
+                    "kind": "struct",
+                    "fields": [
+                        { "name": "flag", "kind": "uint8" },
+                        { "name": "id",   "kind": "uint32" }
+                    ]
+                }
             }
         });
-        let m = map(&schema);
+        let m = map(&root, "S");
         assert_eq!(m.get("flag"), Some(&ByteRange { start: 0, end: 1 }));
         assert_eq!(m.get("id"), Some(&ByteRange { start: 4, end: 8 }));
         assert_eq!(m.total_size(), 8);
@@ -527,34 +519,45 @@ mod tests {
 
     #[test]
     fn u8_then_u32_three_bytes_padding() {
-        let schema = json!({
-            "AlkType:Struct": true,
-            "properties": {
-                "a": { "AlkType:Uint8": true },
-                "b": { "AlkType:Uint32": true }
+        let root = json!({
+            "$defs": {
+                "S": {
+                    "kind": "struct",
+                    "fields": [
+                        { "name": "a", "kind": "uint8" },
+                        { "name": "b", "kind": "uint32" }
+                    ]
+                }
             }
         });
-        let m = map(&schema);
+        let m = map(&root, "S");
         assert_eq!(m.get("a"), Some(&ByteRange { start: 0, end: 1 }));
         assert_eq!(m.get("b"), Some(&ByteRange { start: 4, end: 8 }));
     }
 
     #[test]
     fn nested_struct_dotted_paths() {
-        let schema = json!({
-            "AlkType:Struct": true,
-            "properties": {
-                "header": {
-                    "AlkType:Struct": true,
-                    "properties": {
-                        "magic": { "AlkType:Uint32": true },
-                        "version": { "AlkType:Uint8": true }
-                    }
-                },
-                "body": { "AlkType:Uint32": true }
+        let root = json!({
+            "$defs": {
+                "S": {
+                    "kind": "struct",
+                    "fields": [
+                        {
+                            "name": "header",
+                            "kind": {
+                                "kind": "struct",
+                                "fields": [
+                                    { "name": "magic",   "kind": "uint32" },
+                                    { "name": "version", "kind": "uint8" }
+                                ]
+                            }
+                        },
+                        { "name": "body", "kind": "uint32" }
+                    ]
+                }
             }
         });
-        let m = map(&schema);
+        let m = map(&root, "S");
         assert_eq!(m.get("header.magic"), Some(&ByteRange { start: 0, end: 4 }));
         assert_eq!(
             m.get("header.version"),
@@ -566,18 +569,17 @@ mod tests {
 
     #[test]
     fn array_fixed_count_element_offsets() {
-        let schema = json!({
-            "AlkType:Struct": true,
-            "properties": {
-                "vals": {
-                    "AlkType:Array": true,
-                    "items": { "AlkType:Uint32": true },
-                    "minItems": 3,
-                    "maxItems": 3
+        let root = json!({
+            "$defs": {
+                "S": {
+                    "kind": "struct",
+                    "fields": [
+                        { "name": "vals", "kind": { "kind": "array", "element": "uint32", "count": 3 } }
+                    ]
                 }
             }
         });
-        let m = map(&schema);
+        let m = map(&root, "S");
         assert_eq!(m.get("vals[0]"), Some(&ByteRange { start: 0, end: 4 }));
         assert_eq!(m.get("vals[1]"), Some(&ByteRange { start: 4, end: 8 }));
         assert_eq!(m.get("vals[2]"), Some(&ByteRange { start: 8, end: 12 }));
@@ -585,31 +587,19 @@ mod tests {
     }
 
     #[test]
-    fn array_variable_count_length_prefix() {
-        let schema = json!({
-            "AlkType:Struct": true,
-            "properties": {
-                "vals": {
-                    "AlkType:Array": true,
-                    "items": { "AlkType:Uint32": true }
+    fn variable_string_length_prefix_at_known_offset() {
+        let root = json!({
+            "$defs": {
+                "S": {
+                    "kind": "struct",
+                    "fields": [
+                        { "name": "id",   "kind": "uint32" },
+                        { "name": "name", "kind": "string" }
+                    ]
                 }
             }
         });
-        let m = map(&schema);
-        assert_eq!(m.get("vals"), Some(&ByteRange { start: 0, end: 4 }));
-        assert_eq!(m.total_size(), 4);
-    }
-
-    #[test]
-    fn variable_string_length_prefix_at_known_offset() {
-        let schema = json!({
-            "AlkType:Struct": true,
-            "properties": {
-                "id": { "AlkType:Uint32": true },
-                "name": { "AlkType:String": true }
-            }
-        });
-        let m = map(&schema);
+        let m = map(&root, "S");
         assert_eq!(m.get("id"), Some(&ByteRange { start: 0, end: 4 }));
         assert_eq!(m.get("name"), Some(&ByteRange { start: 4, end: 8 }));
         assert_eq!(m.total_size(), 8);
@@ -617,14 +607,18 @@ mod tests {
 
     #[test]
     fn variable_string_max_length_reservation() {
-        let schema = json!({
-            "AlkType:Struct": true,
-            "properties": {
-                "id": { "AlkType:Uint32": true },
-                "name": { "AlkType:String": true, "maxLength": 256 }
+        let root = json!({
+            "$defs": {
+                "S": {
+                    "kind": "struct",
+                    "fields": [
+                        { "name": "id",   "kind": "uint32" },
+                        { "name": "name", "kind": "string", "maxLength": 256 }
+                    ]
+                }
             }
         });
-        let m = map(&schema);
+        let m = map(&root, "S");
         assert_eq!(m.get("id"), Some(&ByteRange { start: 0, end: 4 }));
         assert_eq!(m.get("name"), Some(&ByteRange { start: 4, end: 260 }));
         assert_eq!(m.total_size(), 260);
@@ -632,14 +626,18 @@ mod tests {
 
     #[test]
     fn variable_string_offset_indirect_eight_bytes() {
-        let schema = json!({
-            "AlkType:Struct": true,
-            "properties": {
-                "id": { "AlkType:Uint32": true },
-                "blob": { "AlkType:String": { "encoding": "offset-indirect" } }
+        let root = json!({
+            "$defs": {
+                "S": {
+                    "kind": "struct",
+                    "fields": [
+                        { "name": "id",   "kind": "uint32" },
+                        { "name": "blob", "kind": "string", "encoding": "offset-indirect" }
+                    ]
+                }
             }
         });
-        let m = map(&schema);
+        let m = map(&root, "S");
         assert_eq!(m.get("id"), Some(&ByteRange { start: 0, end: 4 }));
         assert_eq!(m.get("blob"), Some(&ByteRange { start: 4, end: 12 }));
         assert_eq!(m.total_size(), 12);
@@ -647,99 +645,71 @@ mod tests {
 
     #[test]
     fn union_byte_discriminator_rejected_in_aligned_mode() {
-        let schema = json!({
-            "AlkType:Struct": true,
-            "properties": {
-                "payload": {
-                    "AlkType:Union": true,
-                    "discriminator": {
-                        "kind": "byte",
-                        "offset": 0,
-                        "type": "AlkType:Uint8"
-                    },
+        let root = json!({
+            "$defs": {
+                "S": {
+                    "kind": "struct",
+                    "fields": [
+                        {
+                            "name": "payload",
+                            "kind": { "$ref": "#/$defs/Packet" }
+                        }
+                    ]
+                },
+                "Packet": {
+                    "kind": "union",
+                    "discriminator": { "kind": "byte", "offset": 0, "type": "uint8" },
                     "mapping": {
                         "5": { "$ref": "#/$defs/Read" },
                         "6": { "$ref": "#/$defs/Write" }
                     }
-                }
-            },
-            "$defs": {
+                },
                 "Read": {
-                    "AlkType:Struct": true,
-                    "properties": {
-                        "handle": { "AlkType:Uint32": true },
-                        "length": { "AlkType:Uint32": true }
-                    }
+                    "kind": "struct",
+                    "fields": [
+                        { "name": "handle", "kind": "uint32" },
+                        { "name": "length", "kind": "uint32" }
+                    ]
                 },
                 "Write": {
-                    "AlkType:Struct": true,
-                    "properties": {
-                        "handle": { "AlkType:Uint32": true },
-                        "length": { "AlkType:Uint32": true },
-                        "data": { "AlkType:Uint32": true }
-                    }
+                    "kind": "struct",
+                    "fields": [
+                        { "name": "handle", "kind": "uint32" },
+                        { "name": "length", "kind": "uint32" },
+                        { "name": "data",   "kind": "uint32" }
+                    ]
                 }
             }
         });
-        let err = OffsetMap::compute(&schema).unwrap_err();
+        let doc = BastDoc::new(&root, "S").expect("doc");
+        let err = OffsetMap::compute(&doc).unwrap_err();
         assert!(matches!(err, AlkTypeError::Offset { .. }), "got {err:?}");
         let reason = match err {
             AlkTypeError::Offset { reason, .. } => reason,
             _ => unreachable!(),
         };
-        assert!(reason.contains("ADR-102"), "reason: {reason}");
-    }
-
-    #[test]
-    fn union_field_name_discriminator_rejected_in_aligned_mode() {
-        let schema = json!({
-            "AlkType:Struct": true,
-            "properties": {
-                "event": {
-                    "AlkType:Union": true,
-                    "discriminator": { "kind": "field", "name": "type" },
-                    "mapping": {
-                        "read": { "$ref": "#/$defs/Read" },
-                        "write": { "$ref": "#/$defs/Write" }
-                    }
-                }
-            },
-            "$defs": {
-                "Read": {
-                    "AlkType:Struct": true,
-                    "properties": {
-                        "type": { "AlkType:Uint8": true },
-                        "handle": { "AlkType:Uint32": true }
-                    }
-                },
-                "Write": {
-                    "AlkType:Struct": true,
-                    "properties": {
-                        "type": { "AlkType:Uint8": true },
-                        "handle": { "AlkType:Uint32": true },
-                        "length": { "AlkType:Uint32": true }
-                    }
-                }
-            }
-        });
-        let err = OffsetMap::compute(&schema).unwrap_err();
-        assert!(matches!(err, AlkTypeError::Offset { .. }), "got {err:?}");
+        assert!(reason.contains("ADR-008"), "reason: {reason}");
     }
 
     #[test]
     fn non_final_inline_string_rejected_in_aligned_mode() {
-        let schema = json!({
-            "AlkType:Struct": true,
-            "properties": {
-                "name": { "AlkType:String": true },
-                "id": { "AlkType:Uint32": true }
+        let root = json!({
+            "$defs": {
+                "S": {
+                    "kind": "struct",
+                    "fields": [
+                        { "name": "name", "kind": "string" },
+                        { "name": "id",   "kind": "uint32" }
+                    ]
+                }
             }
         });
-        let err = OffsetMap::compute(&schema).unwrap_err();
+        let doc = BastDoc::new(&root, "S").expect("doc");
+        let err = OffsetMap::compute(&doc).unwrap_err();
         match err {
             AlkTypeError::Offset { field_path, reason } => {
                 assert_eq!(field_path, "name");
-                assert!(reason.contains("ADR-100"), "reason: {reason}");
+                assert!(reason.contains("ADR-006"), "reason: {reason}");
             }
             other => panic!("expected Offset, got {other:?}"),
         }
@@ -747,72 +717,92 @@ mod tests {
 
     #[test]
     fn final_inline_string_allowed_in_aligned_mode() {
-        let schema = json!({
-            "AlkType:Struct": true,
-            "properties": {
-                "id": { "AlkType:Uint32": true },
-                "name": { "AlkType:String": true }
+        let root = json!({
+            "$defs": {
+                "S": {
+                    "kind": "struct",
+                    "fields": [
+                        { "name": "id",   "kind": "uint32" },
+                        { "name": "name", "kind": "string" }
+                    ]
+                }
             }
         });
-        let m = map(&schema);
+        let m = map(&root, "S");
         assert_eq!(m.get("id"), Some(&ByteRange { start: 0, end: 4 }));
         assert_eq!(m.get("name"), Some(&ByteRange { start: 4, end: 8 }));
     }
 
     #[test]
     fn non_final_maxlength_string_allowed_in_aligned_mode() {
-        let schema = json!({
-            "AlkType:Struct": true,
-            "properties": {
-                "name": { "AlkType:String": true, "maxLength": 256 },
-                "id": { "AlkType:Uint32": true }
+        let root = json!({
+            "$defs": {
+                "S": {
+                    "kind": "struct",
+                    "fields": [
+                        { "name": "name", "kind": "string", "maxLength": 256 },
+                        { "name": "id",   "kind": "uint32" }
+                    ]
+                }
             }
         });
-        let m = map(&schema);
+        let m = map(&root, "S");
         assert_eq!(m.get("name"), Some(&ByteRange { start: 0, end: 256 }));
         assert_eq!(m.get("id"), Some(&ByteRange { start: 256, end: 260 }));
     }
 
     #[test]
     fn non_final_offset_indirect_string_allowed_in_aligned_mode() {
-        let schema = json!({
-            "AlkType:Struct": true,
-            "properties": {
-                "blob": { "AlkType:String": { "encoding": "offset-indirect" } },
-                "id": { "AlkType:Uint32": true }
+        let root = json!({
+            "$defs": {
+                "S": {
+                    "kind": "struct",
+                    "fields": [
+                        { "name": "blob", "kind": "string", "encoding": "offset-indirect" },
+                        { "name": "id",   "kind": "uint32" }
+                    ]
+                }
             }
         });
-        let m = map(&schema);
+        let m = map(&root, "S");
         assert_eq!(m.get("blob"), Some(&ByteRange { start: 0, end: 8 }));
         assert_eq!(m.get("id"), Some(&ByteRange { start: 8, end: 12 }));
     }
 
     #[test]
     fn struct_level_align_rounds_up_total() {
-        let schema = json!({
-            "AlkType:Struct": true,
-            "align": 16,
-            "properties": {
-                "flag": { "AlkType:Uint8": true }
+        let root = json!({
+            "$defs": {
+                "S": {
+                    "kind": "struct",
+                    "align": 16,
+                    "fields": [
+                        { "name": "flag", "kind": "uint8" }
+                    ]
+                }
             }
         });
-        let m = map(&schema);
+        let m = map(&root, "S");
         assert_eq!(m.get("flag"), Some(&ByteRange { start: 0, end: 1 }));
         assert_eq!(m.total_size(), 16);
     }
 
     #[test]
     fn field_level_align_overrides_struct_default() {
-        let schema = json!({
-            "AlkType:Struct": true,
-            "align": 1,
-            "properties": {
-                "tag": { "AlkType:Uint8": true },
-                "flag": { "AlkType:Uint8": true, "align": 16 },
-                "id": { "AlkType:Uint32": true }
+        let root = json!({
+            "$defs": {
+                "S": {
+                    "kind": "struct",
+                    "align": 1,
+                    "fields": [
+                        { "name": "tag",  "kind": "uint8" },
+                        { "name": "flag", "kind": "uint8", "align": 16 },
+                        { "name": "id",   "kind": "uint32" }
+                    ]
+                }
             }
         });
-        let m = map(&schema);
+        let m = map(&root, "S");
         assert_eq!(m.get("tag"), Some(&ByteRange { start: 0, end: 1 }));
         assert_eq!(m.get("flag"), Some(&ByteRange { start: 16, end: 17 }));
         assert_eq!(m.get("id"), Some(&ByteRange { start: 20, end: 24 }));
@@ -821,15 +811,19 @@ mod tests {
 
     #[test]
     fn field_align_smaller_than_struct_default() {
-        let schema = json!({
-            "AlkType:Struct": true,
-            "align": 8,
-            "properties": {
-                "a": { "AlkType:Uint8": true },
-                "b": { "AlkType:Uint32": true, "align": 1 }
+        let root = json!({
+            "$defs": {
+                "S": {
+                    "kind": "struct",
+                    "align": 8,
+                    "fields": [
+                        { "name": "a", "kind": "uint8" },
+                        { "name": "b", "kind": "uint32", "align": 1 }
+                    ]
+                }
             }
         });
-        let m = map(&schema);
+        let m = map(&root, "S");
         assert_eq!(m.get("a"), Some(&ByteRange { start: 0, end: 1 }));
         assert_eq!(m.get("b"), Some(&ByteRange { start: 1, end: 5 }));
         assert_eq!(m.total_size(), 8);
@@ -837,30 +831,36 @@ mod tests {
 
     #[test]
     fn iter_returns_all_paths_in_order() {
-        let schema = json!({
-            "AlkType:Struct": true,
-            "properties": {
-                "a": { "AlkType:Uint8": true },
-                "b": { "AlkType:Uint32": true }
+        let root = json!({
+            "$defs": {
+                "S": {
+                    "kind": "struct",
+                    "fields": [
+                        { "name": "a", "kind": "uint8" },
+                        { "name": "b", "kind": "uint32" }
+                    ]
+                }
             }
         });
-        let m = map(&schema);
+        let m = map(&root, "S");
         let paths: Vec<&String> = m.iter().map(|(p, _)| p).collect();
         assert_eq!(paths, vec!["a", "b"]);
     }
 
     #[test]
     fn compute_rejects_non_struct_top_level() {
-        let schema =
-            json!({ "AlkType:Union": true, "discriminator": { "kind": "byte" }, "mapping": {} });
-        let err = OffsetMap::compute(&schema).unwrap_err();
-        assert!(matches!(err, AlkTypeError::Schema(_)));
-    }
-
-    #[test]
-    fn compute_rejects_missing_alktype_kind() {
-        let schema = json!({ "type": "object", "properties": {} });
-        let err = OffsetMap::compute(&schema).unwrap_err();
+        let root = json!({
+            "$defs": {
+                "U": {
+                    "kind": "union",
+                    "discriminator": { "kind": "byte", "offset": 0, "type": "uint8" },
+                    "mapping": { "1": { "$ref": "#/$defs/A" } }
+                },
+                "A": { "kind": "struct", "fields": [] }
+            }
+        });
+        let doc = BastDoc::new(&root, "U").expect("doc");
+        let err = OffsetMap::compute(&doc).unwrap_err();
         assert!(matches!(err, AlkTypeError::Schema(_)));
     }
 
@@ -873,16 +873,4 @@ mod tests {
         assert_eq!(empty.len(), 0);
         assert!(empty.is_empty());
     }
-
-    #[test]
-    fn compute_rejects_nested_struct_without_properties() {
-        let schema = json!({
-            "AlkType:Struct": true,
-            "properties": {
-                "header": { "AlkType:Struct": true }
-            }
-        });
-        let err = OffsetMap::compute(&schema).unwrap_err();
-        assert!(matches!(err, AlkTypeError::Schema(_)), "got {err:?}");
-    }
-}
+}
\ No newline at end of file
diff --git a/src/sequential_reader.rs b/src/sequential_reader.rs
index 75ab960..90a8460 100644
--- a/src/sequential_reader.rs
+++ b/src/sequential_reader.rs
@@ -1,8 +1,8 @@
 //! Packed sequential `SequentialReader` — Mode 1 read-side (ADR-096).
 //!
-//! Walks a buffer field-by-field according to the schema, reading length
-//! prefixes to determine variable-length data positions. Used at read time
-//! when the consumer is parsing an incoming frame.
+//! Walks a buffer field-by-field according to the BAST schema, reading
+//! length prefixes to determine variable-length data positions. Used at
+//! read time when the consumer is parsing an incoming frame.
 //!
 //! The reader is sequential — it cannot jump to field N without reading
 //! fields 0..N-1 first. This is inherent to packed layouts where
@@ -10,9 +10,13 @@
 //! uses the [`crate::data_access`] read functions for all typed reads
 //! and applies the schema's endianness to every multi-byte value.
 
+use crate::bast::{
+    BastArray, BastDefKind, BastDiscriminator, BastDoc, BastField, BastRecord, BastStruct,
+    BastType, BastUnion,
+};
 use crate::data_access;
 use crate::error::AlkTypeError;
-use crate::schema::{self, get_alktype_kind_loose_enum, DiscriminatorKind, Endian, AlkTypeKind, U32_SIZE};
+use crate::schema::{AlkTypeKind, Endian, U32_SIZE};
 use serde_json::Value;
 
 /// A value read from a field during sequential traversal.
@@ -22,52 +26,52 @@ use serde_json::Value;
 /// recurses with a fresh [`SequentialReader`] scoped to the
 /// reported byte range.
 ///
-/// **Known asymmetry**: `AlkType:Record` returns
-/// [`FieldValue::Bytes`] covering the record's byte range, not a typed
-/// `Record { ... }` variant. The consumer recurses into the record's
-/// value schema by walking the borrowed slice. Every other composite
-/// kind returns a typed descriptor; `Record` is the exception (review
-/// #002, N2). A future revision may add a `FieldValue::Record`
-/// variant; for v0.1.0 the `Bytes` form is stable.
+/// **Known asymmetry**: `record` returns [`FieldValue::Bytes`] covering
+/// the record's byte range, not a typed `Record { ... }` variant. The
+/// consumer recurses into the record's value schema by walking the
+/// borrowed slice. Every other composite kind returns a typed
+/// descriptor; `Record` is the exception (review #002, N2). A future
+/// revision may add a `FieldValue::Record` variant; for v0.1.0 the
+/// `Bytes` form is stable.
 #[derive(Debug, PartialEq)]
 pub enum FieldValue<'a> {
-    /// `AlkType:Int8`.
+    /// `int8`.
     I8(i8),
-    /// `AlkType:Int16`.
+    /// `int16`.
     I16(i16),
-    /// `AlkType:Int32`.
+    /// `int32`.
     I32(i32),
-    /// `AlkType:Int64`.
+    /// `int64`.
     I64(i64),
-    /// `AlkType:Uint8`.
+    /// `uint8`.
     U8(u8),
-    /// `AlkType:Uint16`.
+    /// `uint16`.
     U16(u16),
-    /// `AlkType:Uint32`.
+    /// `uint32`.
     U32(u32),
-    /// `AlkType:Uint64`.
+    /// `uint64`.
     U64(u64),
-    /// `AlkType:Float32`.
+    /// `float32`.
     F32(f32),
-    /// `AlkType:Float64`.
+    /// `float64`.
     F64(f64),
-    /// `AlkType:Boolean`.
+    /// `bool`.
     Bool(bool),
-    /// `AlkType:Enum` — `u32` index into the schema's `"enum"` array.
+    /// `enum` — `u32` index into the schema's `values` array.
     Enum(u32),
-    /// `AlkType:String` — borrows from the input buffer.
+    /// `string` — borrows from the input buffer.
     String(&'a str),
-    /// `AlkType:Bytes` — borrows from the input buffer.
+    /// `bytes` — borrows from the input buffer.
     Bytes(&'a [u8]),
-    /// `AlkType:Struct` — the consumer recurses with a new
-    /// [`SequentialReader`] scoped to `start..end`.
+    /// `struct` — the consumer recurses with a new [`SequentialReader`]
+    /// scoped to `start..end`.
     Struct {
         /// Inclusive start of the nested struct's byte range.
         start: usize,
         /// Exclusive end of the nested struct's byte range.
         end: usize,
     },
-    /// `AlkType:Union` — the consumer looks up the variant schema using
+    /// `union` — the consumer looks up the variant schema using
     /// `discriminator` and recurses at `variant_start`.
     Union {
         /// Stringified discriminator value (mapping key).
@@ -75,7 +79,7 @@ pub enum FieldValue<'a> {
         /// Byte offset where the variant struct begins.
         variant_start: usize,
     },
-    /// `AlkType:Array` — the consumer iterates `count` elements of
+    /// `array` — the consumer iterates `count` elements of
     /// stride `element_stride` starting at `element_start`.
     Array {
         /// Number of elements in the array.
@@ -89,9 +93,9 @@ pub enum FieldValue<'a> {
     },
 }
 
-/// Walks a buffer field-by-field according to a schema, reading length
-/// prefixes to determine variable-length data positions. Used at read
-/// time when parsing incoming protocol frames.
+/// Walks a buffer field-by-field according to a BAST schema, reading
+/// length prefixes to determine variable-length data positions. Used at
+/// read time when parsing incoming protocol frames.
 ///
 /// The reader is sequential — it cannot jump to field N without reading
 /// fields 0..N-1 first. This is inherent to packed layouts where
@@ -104,7 +108,8 @@ pub enum FieldValue<'a> {
 /// (which walks all preceding fields to reach the target).
 #[derive(Debug)]
 pub struct SequentialReader {
-    schema: Value,
+    doc_value: Value,
+    root_name: String,
     endian: Endian,
     fields: Vec<(String, Value)>,
     field_index: usize,
@@ -112,38 +117,36 @@ pub struct SequentialReader {
 }
 
 impl SequentialReader {
-    /// Create a new `SequentialReader` from a top-level struct schema.
+    /// Create a new `SequentialReader` from a BAST document.
     ///
-    /// The schema must declare `AlkType:Struct` and have a `properties`
-    /// object. Endianness is parsed via [`Endian::from_schema`].
+    /// The root type must be a struct. Endianness is read from the root
+    /// struct's `endian` annotation (defaults to little-endian).
     ///
     /// # Errors
     ///
-    /// Returns [`AlkTypeError::Schema`] if the schema is not an object,
-    /// does not declare `AlkType:Struct`, or has no `properties` object.
-    pub fn new(schema: &Value) -> Result<Self, AlkTypeError> {
-        let kind = schema::get_alktype_kind(schema)
-            .and_then(|s| s.parse::<AlkTypeKind>().ok())
-            .ok_or_else(|| AlkTypeError::Schema("schema has no AlkType:* kind".to_string()))?;
-        if kind != AlkTypeKind::Struct {
-            return Err(AlkTypeError::Schema(format!(
-                "SequentialReader only supports AlkType:Struct at the top level, got {kind}"
-            )));
-        }
-        let properties = schema
-            .as_object()
-            .and_then(|obj| obj.get("properties"))
-            .and_then(Value::as_object)
-            .ok_or_else(|| {
-                AlkTypeError::Schema("struct schema has no properties object".to_string())
-            })?;
-        let fields: Vec<(String, Value)> = properties
+    /// Returns [`AlkTypeError::Schema`] if the document is malformed, the
+    /// root type is not a struct, or the root struct has no fields.
+    pub fn new(bast_doc: &Value, root_name: &str) -> Result<Self, AlkTypeError> {
+        let doc = BastDoc::new(bast_doc, root_name)?;
+        let root_def = doc.root_def();
+        let struct_node = match root_def.kind() {
+            BastDefKind::Struct(s) => s,
+            other => {
+                return Err(AlkTypeError::Schema(format!(
+                    "SequentialReader only supports a struct at the root, got {kind}",
+                    kind = other.alk_kind()
+                )));
+            }
+        };
+        let endian = struct_node.endian();
+        let fields: Vec<(String, Value)> = struct_node
+            .fields()
             .iter()
-            .map(|(name, value)| (name.clone(), value.clone()))
+            .map(|f| (f.name().to_string(), f.source().clone()))
             .collect();
-        let endian = Endian::from_schema(schema);
         Ok(Self {
-            schema: schema.clone(),
+            doc_value: bast_doc.clone(),
+            root_name: root_name.to_string(),
             endian,
             fields,
             field_index: 0,
@@ -155,9 +158,9 @@ impl SequentialReader {
     ///
     /// Returns `Ok(Some((field_name, value)))` and advances the internal
     /// position, or `Ok(None)` when all fields have been read. Variable-
-    /// length fields (`AlkType:String`/`AlkType:Bytes`) consume their
-    /// 4-byte length prefix plus the data; composite fields advance past
-    /// their computed byte range.
+    /// length fields (`string`/`bytes`) consume their 4-byte length prefix
+    /// plus the data; composite fields advance past their computed byte
+    /// range.
     ///
     /// # Errors
     ///
@@ -240,9 +243,9 @@ impl SequentialReader {
         self.endian
     }
 
-    /// The schema this reader was constructed from.
+    /// The raw BAST document this reader was constructed from.
     pub fn schema(&self) -> &Value {
-        &self.schema
+        &self.doc_value
     }
 
     fn read_field_at<'a>(
@@ -256,9 +259,20 @@ impl SequentialReader {
             .get(index)
             .ok_or_else(|| AlkTypeError::Schema(format!("field index {index} out of range")))?;
         let field_path = self.fields[index].0.as_str();
+        let doc = BastDoc::new(&self.doc_value, &self.root_name)?;
+        let root_def = doc.root_def();
+        let struct_node = match root_def.kind() {
+            BastDefKind::Struct(s) => s,
+            _ => unreachable!("checked in new"),
+        };
+        let field_node = struct_node
+            .fields()
+            .get(index)
+            .ok_or_else(|| AlkTypeError::Schema(format!("field index {index} out of range")))?;
         read_field_value(
             buffer,
-            &self.schema,
+            &doc,
+            field_node,
             field_schema,
             field_path,
             offset,
@@ -271,22 +285,410 @@ impl SequentialReader {
 /// position just past the field. Field paths are used for error
 /// attribution only — this helper does not recurse into nested structs.
 ///
-/// `root_schema` is the top-level schema used to resolve `$ref` pointers
-/// found in nested union variants.
+/// `doc` is the BAST document used to resolve `$ref` pointers found in
+/// nested union variants and array/record element types.
 fn read_field_value<'a>(
     buffer: &'a [u8],
-    root_schema: &Value,
-    field_schema: &Value,
+    doc: &BastDoc<'_>,
+    field: &BastField<'_>,
+    _field_schema: &Value,
     field_path: &str,
     offset: usize,
     endian: Endian,
 ) -> Result<(FieldValue<'a>, usize), AlkTypeError> {
-    let kind = get_alktype_kind_loose_enum(field_schema).ok_or_else(|| {
-        AlkTypeError::Schema(format!(
-            "field {field_path} has no AlkType:* kind: {field_schema}"
-        ))
+    let ty = field.ty();
+    let resolved = doc.resolve_typeref(ty)?;
+
+    match &resolved {
+        BastType::Primitive(AlkTypeKind::Int8) => {
+            let v = data_access::read_i8(buffer, offset, field_path)?;
+            Ok((FieldValue::I8(v), offset + 1))
+        }
+        BastType::Primitive(AlkTypeKind::Int16) => {
+            let v = data_access::read_i16(buffer, offset, field_path, endian)?;
+            Ok((FieldValue::I16(v), offset + 2))
+        }
+        BastType::Primitive(AlkTypeKind::Int32) => {
+            let v = data_access::read_i32(buffer, offset, field_path, endian)?;
+            Ok((FieldValue::I32(v), offset + 4))
+        }
+        BastType::Primitive(AlkTypeKind::Int64) => {
+            let v = data_access::read_i64(buffer, offset, field_path, endian)?;
+            Ok((FieldValue::I64(v), offset + 8))
+        }
+        BastType::Primitive(AlkTypeKind::Uint8) => {
+            let v = data_access::read_u8(buffer, offset, field_path)?;
+            Ok((FieldValue::U8(v), offset + 1))
+        }
+        BastType::Primitive(AlkTypeKind::Uint16) => {
+            let v = data_access::read_u16(buffer, offset, field_path, endian)?;
+            Ok((FieldValue::U16(v), offset + 2))
+        }
+        BastType::Primitive(AlkTypeKind::Uint32) => {
+            let v = data_access::read_u32(buffer, offset, field_path, endian)?;
+            Ok((FieldValue::U32(v), offset + 4))
+        }
+        BastType::Primitive(AlkTypeKind::Uint64) => {
+            let v = data_access::read_u64(buffer, offset, field_path, endian)?;
+            Ok((FieldValue::U64(v), offset + 8))
+        }
+        BastType::Primitive(AlkTypeKind::Float32) => {
+            let v = data_access::read_f32(buffer, offset, field_path, endian)?;
+            Ok((FieldValue::F32(v), offset + 4))
+        }
+        BastType::Primitive(AlkTypeKind::Float64) => {
+            let v = data_access::read_f64(buffer, offset, field_path, endian)?;
+            Ok((FieldValue::F64(v), offset + 8))
+        }
+        BastType::Primitive(AlkTypeKind::Boolean) => {
+            let v = data_access::read_bool(buffer, offset, field_path)?;
+            Ok((FieldValue::Bool(v), offset + 1))
+        }
+        BastType::Enum(_) => {
+            let v = data_access::read_enum(buffer, offset, field_path, endian)?;
+            Ok((FieldValue::Enum(v), offset + 4))
+        }
+        BastType::Primitive(AlkTypeKind::String) => {
+            let s = data_access::read_string(buffer, offset, field_path, endian)?;
+            let total = U32_SIZE + s.len();
+            Ok((FieldValue::String(s), offset + total))
+        }
+        BastType::Primitive(AlkTypeKind::Bytes) => {
+            let b = data_access::read_bytes(buffer, offset, field_path, endian)?;
+            let total = U32_SIZE + b.len();
+            Ok((FieldValue::Bytes(b), offset + total))
+        }
+        BastType::Primitive(AlkTypeKind::Timestamp) => {
+            let s = data_access::read_string(buffer, offset, field_path, endian)?;
+            let total = U32_SIZE + s.len();
+            Ok((FieldValue::String(s), offset + total))
+        }
+        BastType::Struct(s) => {
+            let size = walk_struct_size(doc, s, buffer, offset, endian)?;
+            let end = offset
+                .checked_add(size)
+                .ok_or_else(|| AlkTypeError::Access {
+                    field_path: field_path.to_string(),
+                    reason: format!("struct end {offset} + {size} overflows usize"),
+                })?;
+            Ok((FieldValue::Struct { start: offset, end }, end))
+        }
+        BastType::Union(u) => read_union_value(buffer, doc, u, field_path, offset, endian),
+        BastType::Array(a) => read_array_value(buffer, doc, a, field_path, offset, endian),
+        BastType::Record(r) => read_record_value(buffer, doc, r, field_path, offset, endian),
+        BastType::Ref(_) => Err(AlkTypeError::Schema(format!(
+            "internal: unresolved $ref at {field_path}"
+        ))),
+        BastType::Primitive(k) => Err(AlkTypeError::Schema(format!(
+            "unsupported primitive kind {k} at {field_path}"
+        ))),
+    }
+}
+
+/// Read a `union` field: read the discriminator, return the
+/// variant start offset, and advance past the entire union payload.
+///
+/// For byte-offset discriminators the union occupies
+/// `discriminator_size + variant_size` bytes. Because the variant is a
+/// struct (or a ref to one) whose size depends on variable-length fields,
+/// the variant size is computed by walking the variant struct. The
+/// variant schema is resolved from the `mapping` table using the
+/// stringified discriminator value.
+///
+/// For field-name discriminators the discriminator is itself a
+/// length-prefixed string field. The variant begins immediately after
+/// the discriminator field and is sized by walking the variant struct.
+fn read_union_value<'a>(
+    buffer: &'a [u8],
+    doc: &BastDoc<'_>,
+    union_node: &BastUnion<'_>,
+    field_path: &str,
+    offset: usize,
+    endian: Endian,
+) -> Result<(FieldValue<'a>, usize), AlkTypeError> {
+    let disc = union_node.discriminator();
+    match disc {
+        BastDiscriminator::Byte { offset: disc_offset, disc_type } => {
+            let abs_offset =
+                offset
+                    .checked_add(*disc_offset)
+                    .ok_or_else(|| AlkTypeError::Access {
+                        field_path: field_path.to_string(),
+                        reason: format!(
+                            "discriminator offset {offset} + {disc_offset} overflows usize"
+                        ),
+                    })?;
+            let (disc_value, disc_size) =
+                read_byte_discriminator(buffer, abs_offset, field_path, *disc_type, endian)?;
+            let key = disc_value.to_string();
+            let variant_ty = union_node.variant_for(&key).ok_or_else(|| AlkTypeError::Access {
+                field_path: field_path.to_string(),
+                reason: format!("unknown union discriminator value: {key}"),
+            })?;
+            let variant_start =
+                abs_offset
+                    .checked_add(disc_size)
+                    .ok_or_else(|| AlkTypeError::Access {
+                        field_path: field_path.to_string(),
+                        reason: format!("variant start {abs_offset} + {disc_size} overflows usize"),
+                    })?;
+            let variant_size = resolve_and_walk_variant(
+                doc,
+                variant_ty,
+                buffer,
+                variant_start,
+                endian,
+                field_path,
+            )?;
+            let end =
+                variant_start
+                    .checked_add(variant_size)
+                    .ok_or_else(|| AlkTypeError::Access {
+                        field_path: field_path.to_string(),
+                        reason: format!(
+                            "union end {variant_start} + {variant_size} overflows usize"
+                        ),
+                    })?;
+            Ok((
+                FieldValue::Union {
+                    discriminator: key,
+                    variant_start,
+                },
+                end,
+            ))
+        }
+        BastDiscriminator::Field { name } => {
+            let fields = union_node.fields();
+            let disc_field = fields
+                .iter()
+                .find(|f| f.name() == *name)
+                .ok_or_else(|| {
+                    AlkTypeError::Schema(format!(
+                        "union {field_path} has no discriminator field '{name}'"
+                    ))
+                })?;
+            let disc_path = format!("{field_path}.{name}");
+            let (disc_value, after_disc) =
+                read_field_value(buffer, doc, disc_field, disc_field.source(), &disc_path, offset, endian)?;
+            let key = discriminator_string_value(&disc_value, field_path)?;
+            let variant_ty = union_node.variant_for(&key).ok_or_else(|| AlkTypeError::Access {
+                field_path: field_path.to_string(),
+                reason: format!("unknown union discriminator value: {key}"),
+            })?;
+            let variant_size = resolve_and_walk_variant(
+                doc,
+                variant_ty,
+                buffer,
+                after_disc,
+                endian,
+                field_path,
+            )?;
+            let end = after_disc
+                .checked_add(variant_size)
+                .ok_or_else(|| AlkTypeError::Access {
+                    field_path: field_path.to_string(),
+                    reason: format!("union end {after_disc} + {variant_size} overflows usize"),
+                })?;
+            Ok((
+                FieldValue::Union {
+                    discriminator: key,
+                    variant_start: after_disc,
+                },
+                end,
+            ))
+        }
+    }
+}
+
+/// Read a byte-offset discriminator integer and return its value (as a
+/// `u32`) plus its byte size.
+fn read_byte_discriminator(
+    buffer: &[u8],
+    offset: usize,
+    field_path: &str,
+    disc_type: AlkTypeKind,
+    endian: Endian,
+) -> Result<(u32, usize), AlkTypeError> {
+    match disc_type {
+        AlkTypeKind::Uint8 => {
+            let v = data_access::read_u8(buffer, offset, field_path)?;
+            Ok((u32::from(v), 1))
+        }
+        AlkTypeKind::Uint16 => {
+            let v = data_access::read_u16(buffer, offset, field_path, endian)?;
+            Ok((u32::from(v), 2))
+        }
+        AlkTypeKind::Uint32 => {
+            let v = data_access::read_u32(buffer, offset, field_path, endian)?;
+            Ok((v, 4))
+        }
+        other => Err(AlkTypeError::Schema(format!(
+            "unsupported byte discriminator type: {other}"
+        ))),
+    }
+}
+
+/// Stringify a field-name discriminator value. Only the common kinds
+/// (String, Uint8/16/32, Enum) are supported — anything else is a schema
+/// error.
+fn discriminator_string_value(
+    value: &FieldValue<'_>,
+    field_path: &str,
+) -> Result<String, AlkTypeError> {
+    match value {
+        FieldValue::String(s) => Ok(s.to_string()),
+        FieldValue::U8(v) => Ok(v.to_string()),
+        FieldValue::U16(v) => Ok(v.to_string()),
+        FieldValue::U32(v) => Ok(v.to_string()),
+        FieldValue::Enum(v) => Ok(v.to_string()),
+        other => Err(AlkTypeError::Schema(format!(
+            "union {field_path} has unsupported field discriminator kind: {other:?}"
+        ))),
+    }
+}
+
+/// Read an `array` field: the count is known from the BAST `count`
+/// field. Fixed-size elements produce a non-zero stride so the consumer
+/// can index directly; variable-length elements produce a stride of `0`
+/// so the consumer must walk each element sequentially.
+fn read_array_value<'a>(
+    buffer: &'a [u8],
+    doc: &BastDoc<'_>,
+    array: &BastArray<'_>,
+    field_path: &str,
+    offset: usize,
+    endian: Endian,
+) -> Result<(FieldValue<'a>, usize), AlkTypeError> {
+    let element_ty = array.element();
+    let resolved_elem = doc.resolve_typeref(element_ty)?;
+    let elem_kind = resolved_elem.alk_kind();
+    let count = array.count();
+    let count_u32 = u32::try_from(count).map_err(|_| AlkTypeError::Access {
+        field_path: field_path.to_string(),
+        reason: format!("array count {count} overflows u32"),
     })?;
 
+    let element_stride = if elem_kind.is_fixed_size() {
+        elem_kind.type_size().unwrap_or(0)
+    } else {
+        0
+    };
+
+    let total = if element_stride == 0 {
+        walk_variable_array_size(
+            doc,
+            &resolved_elem,
+            buffer,
+            offset,
+            count,
+            endian,
+            field_path,
+        )?
+    } else {
+        count
+            .checked_mul(element_stride)
+            .ok_or_else(|| AlkTypeError::Access {
+                field_path: field_path.to_string(),
+                reason: format!("array size {count} × stride {element_stride} overflows usize"),
+            })?
+    };
+
+    let end = offset
+        .checked_add(total)
+        .ok_or_else(|| AlkTypeError::Access {
+            field_path: field_path.to_string(),
+            reason: format!("array end {offset} + {total} overflows usize"),
+        })?;
+
+    Ok((
+        FieldValue::Array {
+            count: count_u32,
+            element_start: offset,
+            element_stride,
+        },
+        end,
+    ))
+}
+
+/// Walk `count` variable-length array elements starting at `offset` and
+/// return the total byte size of the element data.
+fn walk_variable_array_size(
+    doc: &BastDoc<'_>,
+    elem_ty: &BastType<'_>,
+    buffer: &[u8],
+    start: usize,
+    count: usize,
+    endian: Endian,
+    field_path: &str,
+) -> Result<usize, AlkTypeError> {
+    let mut position = start;
+    for i in 0..count {
+        let element_path = format!("{field_path}[{i}]");
+        let (_, new_position) = read_typeref_value(
+            buffer,
+            doc,
+            elem_ty,
+            &element_path,
+            position,
+            endian,
+        )?;
+        if new_position < position {
+            return Err(AlkTypeError::Access {
+                field_path: element_path,
+                reason: format!("array element walked backwards: {position} → {new_position}"),
+            });
+        }
+        position = new_position;
+    }
+    Ok(position - start)
+}
+
+/// Read a value for a resolved `BastType` (used for array elements and
+/// record values, which are TypeRefs, not fields). Splits the
+/// `field`-bearing path from the `BastType`-only path.
+fn read_typeref_value<'a>(
+    buffer: &'a [u8],
+    doc: &BastDoc<'_>,
+    ty: &BastType<'_>,
+    field_path: &str,
+    offset: usize,
+    endian: Endian,
+) -> Result<(FieldValue<'a>, usize), AlkTypeError> {
+    let resolved = doc.resolve_typeref(ty)?;
+    match &resolved {
+        BastType::Struct(s) => {
+            let size = walk_struct_size(doc, s, buffer, offset, endian)?;
+            let end = offset
+                .checked_add(size)
+                .ok_or_else(|| AlkTypeError::Access {
+                    field_path: field_path.to_string(),
+                    reason: format!("struct end {offset} + {size} overflows usize"),
+                })?;
+            Ok((FieldValue::Struct { start: offset, end }, end))
+        }
+        BastType::Union(u) => read_union_value(buffer, doc, u, field_path, offset, endian),
+        BastType::Array(a) => read_array_value(buffer, doc, a, field_path, offset, endian),
+        BastType::Record(r) => read_record_value(buffer, doc, r, field_path, offset, endian),
+        BastType::Ref(_) => Err(AlkTypeError::Schema(format!(
+            "internal: unresolved $ref at {field_path}"
+        ))),
+        BastType::Enum(_) => {
+            let v = data_access::read_enum(buffer, offset, field_path, endian)?;
+            Ok((FieldValue::Enum(v), offset + 4))
+        }
+        BastType::Primitive(k) => read_primitive_value(buffer, *k, field_path, offset, endian),
+    }
+}
+
+/// Read a primitive value. Shared by `read_field_value` and
+/// `read_typeref_value`.
+fn read_primitive_value<'a>(
+    buffer: &'a [u8],
+    kind: AlkTypeKind,
+    field_path: &str,
+    offset: usize,
+    endian: Endian,
+) -> Result<(FieldValue<'a>, usize), AlkTypeError> {
     match kind {
         AlkTypeKind::Int8 => {
             let v = data_access::read_i8(buffer, offset, field_path)?;
@@ -332,10 +734,6 @@ fn read_field_value<'a>(
             let v = data_access::read_bool(buffer, offset, field_path)?;
             Ok((FieldValue::Bool(v), offset + 1))
         }
-        AlkTypeKind::Enum => {
-            let v = data_access::read_enum(buffer, offset, field_path, endian)?;
-            Ok((FieldValue::Enum(v), offset + 4))
-        }
         AlkTypeKind::String => {
             let s = data_access::read_string(buffer, offset, field_path, endian)?;
             let total = U32_SIZE + s.len();
@@ -351,374 +749,41 @@ fn read_field_value<'a>(
             let total = U32_SIZE + s.len();
             Ok((FieldValue::String(s), offset + total))
         }
-        AlkTypeKind::Struct => {
-            let size = walk_struct_size(root_schema, field_schema, buffer, offset, endian)?;
-            let end = offset
-                .checked_add(size)
-                .ok_or_else(|| AlkTypeError::Access {
-                    field_path: field_path.to_string(),
-                    reason: format!("struct end {offset} + {size} overflows usize"),
-                })?;
-            Ok((FieldValue::Struct { start: offset, end }, end))
-        }
-        AlkTypeKind::Union => read_union_value(
-            buffer,
-            root_schema,
-            field_schema,
-            field_path,
-            offset,
-            endian,
-        ),
-        AlkTypeKind::Array => read_array_value(
-            buffer,
-            root_schema,
-            field_schema,
-            field_path,
-            offset,
-            endian,
-        ),
-        AlkTypeKind::Record => read_record_value(
-            buffer,
-            root_schema,
-            field_schema,
-            field_path,
-            offset,
-            endian,
-        ),
-    }
-}
-
-/// Read a `AlkType:Union` field: read the discriminator, return the
-/// variant start offset, and advance past the entire union payload.
-///
-/// For byte-offset discriminators the union occupies
-/// `discriminator_size + variant_size` bytes. Because the variant is a
-/// struct (or a ref to one) whose size depends on variable-length fields,
-/// the variant size is computed by walking the variant struct. The
-/// variant schema is resolved from the `"mapping"` table using the
-/// stringified discriminator value.
-///
-/// For field-name discriminators the discriminator is itself a
-/// length-prefixed string field. The variant begins immediately after
-/// the discriminator field and is sized by walking the variant struct.
-fn read_union_value<'a>(
-    buffer: &'a [u8],
-    root_schema: &Value,
-    schema: &Value,
-    field_path: &str,
-    offset: usize,
-    endian: Endian,
-) -> Result<(FieldValue<'a>, usize), AlkTypeError> {
-    let disc = schema::parse_discriminator(schema)?;
-    let mapping = schema
-        .as_object()
-        .and_then(|obj| obj.get("mapping"))
-        .and_then(Value::as_object)
-        .ok_or_else(|| AlkTypeError::Schema(format!("union {field_path} has no mapping object")))?;
-
-    match disc {
-        DiscriminatorKind::Byte {
-            offset: disc_offset,
-            disc_type,
-        } => {
-            let abs_offset =
-                offset
-                    .checked_add(disc_offset)
-                    .ok_or_else(|| AlkTypeError::Access {
-                        field_path: field_path.to_string(),
-                        reason: format!(
-                            "discriminator offset {offset} + {disc_offset} overflows usize"
-                        ),
-                    })?;
-            let (disc_value, disc_size) =
-                read_byte_discriminator(buffer, abs_offset, field_path, disc_type, endian)?;
-            let key = disc_value.to_string();
-            let variant_schema = mapping.get(&key).ok_or_else(|| AlkTypeError::Access {
-                field_path: field_path.to_string(),
-                reason: format!("unknown union discriminator value: {key}"),
-            })?;
-            let variant_start =
-                abs_offset
-                    .checked_add(disc_size)
-                    .ok_or_else(|| AlkTypeError::Access {
-                        field_path: field_path.to_string(),
-                        reason: format!("variant start {abs_offset} + {disc_size} overflows usize"),
-                    })?;
-            let variant_size = resolve_and_walk_variant(
-                root_schema,
-                schema,
-                variant_schema,
-                buffer,
-                variant_start,
-                endian,
-                field_path,
-            )?;
-            let end =
-                variant_start
-                    .checked_add(variant_size)
-                    .ok_or_else(|| AlkTypeError::Access {
-                        field_path: field_path.to_string(),
-                        reason: format!(
-                            "union end {variant_start} + {variant_size} overflows usize"
-                        ),
-                    })?;
-            Ok((
-                FieldValue::Union {
-                    discriminator: key,
-                    variant_start,
-                },
-                end,
-            ))
-        }
-        DiscriminatorKind::Field { name } => {
-            let properties = schema
-                .as_object()
-                .and_then(|obj| obj.get("properties"))
-                .and_then(Value::as_object)
-                .ok_or_else(|| {
-                    AlkTypeError::Schema(format!(
-                        "field-name union {field_path} has no properties object"
-                    ))
-                })?;
-            let disc_schema = properties.get(&name).ok_or_else(|| {
-                AlkTypeError::Schema(format!(
-                    "union {field_path} has no discriminator field '{name}'"
-                ))
-            })?;
-            let (disc_value, after_disc) =
-                read_field_value(buffer, root_schema, disc_schema, field_path, offset, endian)?;
-            let key = discriminator_string_value(&disc_value, field_path)?;
-            let variant_schema = mapping.get(&key).ok_or_else(|| AlkTypeError::Access {
-                field_path: field_path.to_string(),
-                reason: format!("unknown union discriminator value: {key}"),
-            })?;
-            let variant_size = resolve_and_walk_variant(
-                root_schema,
-                schema,
-                variant_schema,
-                buffer,
-                after_disc,
-                endian,
-                field_path,
-            )?;
-            let end = after_disc
-                .checked_add(variant_size)
-                .ok_or_else(|| AlkTypeError::Access {
-                    field_path: field_path.to_string(),
-                    reason: format!("union end {after_disc} + {variant_size} overflows usize"),
-                })?;
-            Ok((
-                FieldValue::Union {
-                    discriminator: key,
-                    variant_start: after_disc,
-                },
-                end,
-            ))
-        }
-    }
-}
-
-/// Read a byte-offset discriminator integer and return its value (as a
-/// `u32`) plus its byte size.
-fn read_byte_discriminator(
-    buffer: &[u8],
-    offset: usize,
-    field_path: &str,
-    disc_type: AlkTypeKind,
-    endian: Endian,
-) -> Result<(u32, usize), AlkTypeError> {
-    match disc_type {
-        AlkTypeKind::Uint8 => {
-            let v = data_access::read_u8(buffer, offset, field_path)?;
-            Ok((v as u32, 1))
-        }
-        AlkTypeKind::Uint16 => {
-            let v = data_access::read_u16(buffer, offset, field_path, endian)?;
-            Ok((v as u32, 2))
-        }
-        AlkTypeKind::Uint32 => {
-            let v = data_access::read_u32(buffer, offset, field_path, endian)?;
-            Ok((v, 4))
-        }
         other => Err(AlkTypeError::Schema(format!(
-            "unsupported byte discriminator type: {other}"
+            "{other} is not a primitive readable by read_primitive_value"
         ))),
     }
 }
 
-/// Stringify a field-name discriminator value. Only the common kinds
-/// (String, Uint8/16/32, Enum) are supported — anything else is a schema
-/// error.
-fn discriminator_string_value(
-    value: &FieldValue<'_>,
-    field_path: &str,
-) -> Result<String, AlkTypeError> {
-    match value {
-        FieldValue::String(s) => Ok(s.to_string()),
-        FieldValue::U8(v) => Ok(v.to_string()),
-        FieldValue::U16(v) => Ok(v.to_string()),
-        FieldValue::U32(v) => Ok(v.to_string()),
-        FieldValue::Enum(v) => Ok(v.to_string()),
-        other => Err(AlkTypeError::Schema(format!(
-            "union {field_path} has unsupported field discriminator kind: {other:?}"
-        ))),
-    }
-}
-
-/// Read a `AlkType:Array` field: read the count (fixed via `minItems`/
-/// `maxItems` equality, or a 4-byte count prefix) and compute the
-/// element stride. Fixed-size elements produce a non-zero stride so the
-/// consumer can index directly; variable-length elements produce a
-/// stride of `0` so the consumer must walk each element sequentially.
-fn read_array_value<'a>(
-    buffer: &'a [u8],
-    root_schema: &Value,
-    schema: &Value,
-    field_path: &str,
-    offset: usize,
-    endian: Endian,
-) -> Result<(FieldValue<'a>, usize), AlkTypeError> {
-    let obj = schema.as_object().ok_or_else(|| {
-        AlkTypeError::Schema(format!("array {field_path} schema is not an object"))
-    })?;
-    let items_schema = obj
-        .get("items")
-        .ok_or_else(|| AlkTypeError::Schema(format!("array {field_path} has no items schema")))?;
-
-    let min = obj
-        .get("minItems")
-        .and_then(Value::as_u64)
-        .map(|n| n as u32);
-    let max = obj
-        .get("maxItems")
-        .and_then(Value::as_u64)
-        .map(|n| n as u32);
-    let fixed_count = matches!((min, max), (Some(a), Some(b)) if a == b);
-    let (count, element_start) = if fixed_count {
-        let count = min.ok_or_else(|| {
-            AlkTypeError::Schema(format!(
-                "array {field_path} declared fixed count but minItems is absent"
-            ))
-        })?;
-        (count, offset)
-    } else {
-        let count = data_access::read_u32(buffer, offset, field_path, endian)?;
-        (count, offset + U32_SIZE)
-    };
-
-    let element_kind = get_alktype_kind_loose_enum(items_schema).ok_or_else(|| {
-        AlkTypeError::Schema(format!(
-            "array {field_path} items schema has no AlkType:* kind"
-        ))
-    })?;
-
-    let element_stride = if element_kind.is_fixed_size() {
-        element_kind.type_size().unwrap_or(0)
-    } else {
-        0
-    };
-
-    let total = if element_stride == 0 {
-        walk_variable_array_size(
-            root_schema,
-            items_schema,
-            buffer,
-            element_start,
-            count,
-            endian,
-            field_path,
-        )?
-    } else {
-        (count as usize)
-            .checked_mul(element_stride)
-            .ok_or_else(|| AlkTypeError::Access {
-                field_path: field_path.to_string(),
-                reason: format!("array size {count} × stride {element_stride} overflows usize"),
-            })?
-    };
-
-    let end = element_start
-        .checked_add(total)
-        .ok_or_else(|| AlkTypeError::Access {
-            field_path: field_path.to_string(),
-            reason: format!("array end {element_start} + {total} overflows usize"),
-        })?;
-
-    Ok((
-        FieldValue::Array {
-            count,
-            element_start,
-            element_stride,
-        },
-        end,
-    ))
-}
-
-/// Walk `count` variable-length array elements starting at `offset` and
-/// return the total byte size of the element data (excluding any count
-/// prefix, which the caller has already accounted for).
-fn walk_variable_array_size(
-    root_schema: &Value,
-    items_schema: &Value,
-    buffer: &[u8],
-    start: usize,
-    count: u32,
-    endian: Endian,
-    field_path: &str,
-) -> Result<usize, AlkTypeError> {
-    let mut position = start;
-    for i in 0..count {
-        let element_path = format!("{field_path}[{i}]");
-        let (_, new_position) = read_field_value(
-            buffer,
-            root_schema,
-            items_schema,
-            &element_path,
-            position,
-            endian,
-        )?;
-        if new_position < position {
-            return Err(AlkTypeError::Access {
-                field_path: element_path,
-                reason: format!("array element walked backwards: {position} → {new_position}"),
-            });
-        }
-        position = new_position;
-    }
-    Ok(position - start)
-}
-
-/// Read a `AlkType:Record` field: `[count: u32]` followed by `count`
-/// entries of `[key_len: u32][key_bytes][value]`. Returns the total size
-/// consumed. The reader does not decode the entries — the consumer
-/// recurses into the record's value schema.
+/// Read a `record` field: `[count: u32]` followed by `count` entries of
+/// `[key_len: u32][key_bytes][value]`. Returns the total size consumed.
+/// The reader does not decode the entries — the consumer recurses into
+/// the record's value schema.
 ///
 /// Returns the record's byte range as [`FieldValue::Bytes`] (the one
 /// composite kind that does not return a typed descriptor — see the
 /// `FieldValue` enum doc for the known asymmetry).
 fn read_record_value<'a>(
     buffer: &'a [u8],
-    root_schema: &Value,
-    schema: &Value,
+    doc: &BastDoc<'_>,
+    record: &BastRecord<'_>,
     field_path: &str,
     offset: usize,
     endian: Endian,
 ) -> Result<(FieldValue<'a>, usize), AlkTypeError> {
     let count = data_access::read_u32(buffer, offset, field_path, endian)?;
-    let value_schema = schema
-        .as_object()
-        .and_then(|obj| obj.get("values"))
-        .ok_or_else(|| AlkTypeError::Schema(format!("record {field_path} has no values schema")))?;
+    let count_usize = count as usize;
+    let values_ty = record.values();
     let mut position = offset + U32_SIZE;
-    for i in 0..count {
+    for i in 0..count_usize {
         let entry_path = format!("{field_path}[{i}].key");
         let key = data_access::read_string(buffer, position, &entry_path, endian)?;
         position += U32_SIZE + key.len();
         let value_path = format!("{field_path}[{i}].value");
-        let (_, new_position) = read_field_value(
+        let (_, new_position) = read_typeref_value(
             buffer,
-            root_schema,
-            value_schema,
+            doc,
+            values_ty,
             &value_path,
             position,
             endian,
@@ -728,39 +793,24 @@ fn read_record_value<'a>(
     Ok((FieldValue::Bytes(&buffer[offset..position]), position))
 }
 
-/// Resolve a variant schema and walk its size starting at
-/// `variant_start`. Used by [`read_union_value`]. Inline schemas are
-/// returned as-is; `$ref` pointers are resolved against the union
-/// schema's own `$defs` block, then the root schema's `$defs` block.
+/// Resolve a variant type and walk its size starting at `variant_start`.
+/// Used by [`read_union_value`].
 fn resolve_and_walk_variant(
-    root_schema: &Value,
-    union_schema: &Value,
-    variant_schema: &Value,
+    doc: &BastDoc<'_>,
+    variant_ty: &BastType<'_>,
     buffer: &[u8],
     variant_start: usize,
     endian: Endian,
     field_path: &str,
 ) -> Result<usize, AlkTypeError> {
-    let resolved =
-        resolve_variant_schema(root_schema, union_schema, variant_schema).ok_or_else(|| {
-            AlkTypeError::Schema(format!(
-                "union {field_path} variant could not be resolved: {variant_schema}"
-            ))
-        })?;
-    let kind = get_alktype_kind_loose_enum(resolved).ok_or_else(|| {
-        AlkTypeError::Schema(format!(
-            "union {field_path} variant has no AlkType:* kind: {resolved}"
-        ))
-    })?;
-    match kind {
-        AlkTypeKind::Struct => {
-            walk_struct_size(root_schema, resolved, buffer, variant_start, endian)
-        }
-        AlkTypeKind::Union => {
+    let variant_def = doc.resolve_typeref_as_def(variant_ty, field_path)?;
+    match variant_def.kind() {
+        BastDefKind::Struct(s) => walk_struct_size(doc, s, buffer, variant_start, endian),
+        BastDefKind::Union(u) => {
             let (_, end) = read_union_value(
                 buffer,
-                root_schema,
-                resolved,
+                doc,
+                u,
                 field_path,
                 variant_start,
                 endian,
@@ -768,80 +818,33 @@ fn resolve_and_walk_variant(
             Ok(end - variant_start)
         }
         other => Err(AlkTypeError::Schema(format!(
-            "union {field_path} variant must be Struct or Union, got {other}"
+            "union {field_path} variant must be Struct or Union, got {kind}",
+            kind = other.alk_kind()
         ))),
     }
 }
 
-/// Resolve a variant schema. Inline schemas (objects with a `AlkType:*`
-/// kind) are returned directly. `$ref` pointers of the form
-/// `#/$defs/<name>` are resolved against `union_schema["$defs"]` first,
-/// then `root_schema["$defs"]`. Returns `None` if the ref cannot be
-/// resolved or the target is absent.
-fn resolve_variant_schema<'a>(
-    root_schema: &'a Value,
-    union_schema: &'a Value,
-    variant: &'a Value,
-) -> Option<&'a Value> {
-    let obj = variant.as_object()?;
-    if let Some(ref_value) = obj.get("$ref").and_then(Value::as_str) {
-        if !ref_value.starts_with("#/$defs/") {
-            return None;
-        }
-        let name = &ref_value["#/$defs/".len()..];
-        for host in [union_schema, root_schema] {
-            if let Some(target) = host
-                .as_object()
-                .and_then(|o| o.get("$defs"))
-                .and_then(Value::as_object)
-                .and_then(|d| d.get(name))
-            {
-                return Some(target);
-            }
-        }
-        return None;
-    }
-    if get_alktype_kind_loose_enum(variant).is_some() {
-        Some(variant)
-    } else {
-        None
-    }
-}
-
-/// Walk the fields of a struct schema sequentially, reading length
-/// prefixes for variable-length fields, and return the total byte size
-/// of the struct starting at `offset`. Does not return field values —
-/// only advances the cursor to compute the struct's end position.
+/// Walk the fields of a struct sequentially, reading length prefixes for
+/// variable-length fields, and return the total byte size of the struct
+/// starting at `offset`. Does not return field values — only advances
+/// the cursor to compute the struct's end position.
 ///
-/// `root_schema` is the top-level schema used to resolve `$ref` pointers
-/// found in nested union variants.
+/// `doc` is the BAST document used to resolve `$ref` pointers found in
+/// nested union variants.
 fn walk_struct_size(
-    root_schema: &Value,
-    schema: &Value,
+    doc: &BastDoc<'_>,
+    struct_node: &BastStruct<'_>,
     buffer: &[u8],
     offset: usize,
     endian: Endian,
 ) -> Result<usize, AlkTypeError> {
-    let properties = schema
-        .as_object()
-        .and_then(|obj| obj.get("properties"))
-        .and_then(Value::as_object)
-        .ok_or_else(|| {
-            AlkTypeError::Schema("struct schema has no properties object".to_string())
-        })?;
     let mut position = offset;
-    for (name, field_schema) in properties.iter() {
-        let (_, new_position) = read_field_value(
-            buffer,
-            root_schema,
-            field_schema,
-            name.as_str(),
-            position,
-            endian,
-        )?;
+    for field in struct_node.fields() {
+        let (_, new_position) =
+            read_field_value(buffer, doc, field, field.source(), field.name(), position, endian)?;
         if new_position < position {
             return Err(AlkTypeError::Access {
-                field_path: name.clone(),
+                field_path: field.name().to_string(),
                 reason: format!("struct field walked backwards: {position} → {new_position}"),
             });
         }
@@ -874,15 +877,23 @@ mod tests {
         total
     }
 
+    fn reader(root: &Value, name: &str) -> SequentialReader {
+        SequentialReader::new(root, name).expect("reader")
+    }
+
     #[test]
     fn reads_fixed_size_fields_in_sequence() {
-        let schema = json!({
-            "AlkType:Struct": true,
-            "endian": "little",
-            "properties": {
-                "a": { "AlkType:Uint8": true },
-                "b": { "AlkType:Uint32": true },
-                "c": { "AlkType:Uint16": true }
+        let root = json!({
+            "$defs": {
+                "S": {
+                    "kind": "struct",
+                    "endian": "little",
+                    "fields": [
+                        { "name": "a", "kind": "uint8" },
+                        { "name": "b", "kind": "uint32" },
+                        { "name": "c", "kind": "uint16" }
+                    ]
+                }
             }
         });
         let mut buf = vec![0u8; 16];
@@ -890,7 +901,7 @@ mod tests {
         write_u32(&mut buf, 1, 0x01020304, LE);
         buf[5..7].copy_from_slice(&1000u16.to_le_bytes());
 
-        let mut reader = SequentialReader::new(&schema).expect("reader");
+        let mut reader = reader(&root, "S");
         assert_eq!(reader.position(), 0);
 
         let (name, value) = reader.read_next(&buf).unwrap().expect("field 0");
@@ -913,12 +924,16 @@ mod tests {
 
     #[test]
     fn reads_variable_length_string_with_length_prefix() {
-        let schema = json!({
-            "AlkType:Struct": true,
-            "properties": {
-                "id": { "AlkType:Uint8": true },
-                "name": { "AlkType:String": true },
-                "tail": { "AlkType:Uint8": true }
+        let root = json!({
+            "$defs": {
+                "S": {
+                    "kind": "struct",
+                    "fields": [
+                        { "name": "id",   "kind": "uint8" },
+                        { "name": "name", "kind": "string" },
+                        { "name": "tail", "kind": "uint8" }
+                    ]
+                }
             }
         });
         let mut buf = vec![0u8; 32];
@@ -927,7 +942,7 @@ mod tests {
         let after = 1 + written;
         buf[after] = 99;
 
-        let mut reader = SequentialReader::new(&schema).unwrap();
+        let mut reader = reader(&root, "S");
         let (name, value) = reader.read_next(&buf).unwrap().unwrap();
         assert_eq!(name, "id");
         assert_eq!(value, FieldValue::U8(7));
@@ -948,10 +963,12 @@ mod tests {
 
     #[test]
     fn reads_bytes_field() {
-        let schema = json!({
-            "AlkType:Struct": true,
-            "properties": {
-                "blob": { "AlkType:Bytes": true }
+        let root = json!({
+            "$defs": {
+                "S": {
+                    "kind": "struct",
+                    "fields": [ { "name": "blob", "kind": "bytes" } ]
+                }
             }
         });
         let mut buf = vec![0u8; 16];
@@ -959,7 +976,7 @@ mod tests {
         write_u32(&mut buf, 0, 3, LE);
         buf[4..7].copy_from_slice(&payload);
 
-        let mut reader = SequentialReader::new(&schema).unwrap();
+        let mut reader = reader(&root, "S");
         let (name, value) = reader.read_next(&buf).unwrap().unwrap();
         assert_eq!(name, "blob");
         assert_eq!(value, FieldValue::Bytes(&payload[..]));
@@ -968,16 +985,18 @@ mod tests {
 
     #[test]
     fn respects_big_endian() {
-        let schema = json!({
-            "AlkType:Struct": true,
-            "endian": "big",
-            "properties": {
-                "id": { "AlkType:Uint32": true }
+        let root = json!({
+            "$defs": {
+                "S": {
+                    "kind": "struct",
+                    "endian": "big",
+                    "fields": [ { "name": "id", "kind": "uint32" } ]
+                }
             }
         });
         let mut buf = vec![0u8; 8];
         write_u32(&mut buf, 0, 0x01020304, BE);
-        let mut reader = SequentialReader::new(&schema).unwrap();
+        let mut reader = reader(&root, "S");
         let (_, value) = reader.read_next(&buf).unwrap().unwrap();
         assert_eq!(value, FieldValue::U32(0x01020304));
         assert_eq!(reader.endian(), BE);
@@ -985,15 +1004,19 @@ mod tests {
 
     #[test]
     fn reset_rewinds_cursor() {
-        let schema = json!({
-            "AlkType:Struct": true,
-            "properties": {
-                "a": { "AlkType:Uint8": true },
-                "b": { "AlkType:Uint8": true }
+        let root = json!({
+            "$defs": {
+                "S": {
+                    "kind": "struct",
+                    "fields": [
+                        { "name": "a", "kind": "uint8" },
+                        { "name": "b", "kind": "uint8" }
+                    ]
+                }
             }
         });
         let buf = [10u8, 20u8];
-        let mut reader = SequentialReader::new(&schema).unwrap();
+        let mut reader = reader(&root, "S");
         let _ = reader.read_next(&buf).unwrap().unwrap();
         let _ = reader.read_next(&buf).unwrap().unwrap();
         assert_eq!(reader.position(), 2);
@@ -1007,12 +1030,16 @@ mod tests {
 
     #[test]
     fn read_field_walks_preceding_fields() {
-        let schema = json!({
-            "AlkType:Struct": true,
-            "properties": {
-                "a": { "AlkType:Uint8": true },
-                "b": { "AlkType:Uint32": true },
-                "c": { "AlkType:Uint8": true }
+        let root = json!({
+            "$defs": {
+                "S": {
+                    "kind": "struct",
+                    "fields": [
+                        { "name": "a", "kind": "uint8" },
+                        { "name": "b", "kind": "uint32" },
+                        { "name": "c", "kind": "uint8" }
+                    ]
+                }
             }
         });
         let mut buf = vec![0u8; 16];
@@ -1020,7 +1047,7 @@ mod tests {
         write_u32(&mut buf, 1, 0xDEADBEEF, LE);
         buf[5] = 9;
 
-        let mut reader = SequentialReader::new(&schema).unwrap();
+        let mut reader = reader(&root, "S");
         let value = reader.read_field(&buf, "c").unwrap();
         assert_eq!(value, FieldValue::U8(9));
         assert_eq!(reader.position(), 6);
@@ -1032,61 +1059,69 @@ mod tests {
 
     #[test]
     fn read_field_unknown_returns_schema_error() {
-        let schema = json!({
-            "AlkType:Struct": true,
-            "properties": { "a": { "AlkType:Uint8": true } }
+        let root = json!({
+            "$defs": {
+                "S": {
+                    "kind": "struct",
+                    "fields": [ { "name": "a", "kind": "uint8" } ]
+                }
+            }
         });
         let buf = [0u8; 4];
-        let mut reader = SequentialReader::new(&schema).unwrap();
+        let mut reader = reader(&root, "S");
         let err = reader.read_field(&buf, "missing").unwrap_err();
         assert!(matches!(err, AlkTypeError::Schema(_)), "got {err:?}");
     }
 
     #[test]
     fn buffer_too_short_returns_access_error() {
-        let schema = json!({
-            "AlkType:Struct": true,
-            "properties": {
-                "id": { "AlkType:Uint32": true }
+        let root = json!({
+            "$defs": {
+                "S": {
+                    "kind": "struct",
+                    "fields": [ { "name": "id", "kind": "uint32" } ]
+                }
             }
         });
         let buf = [0u8; 2];
-        let mut reader = SequentialReader::new(&schema).unwrap();
+        let mut reader = reader(&root, "S");
         let err = reader.read_next(&buf).unwrap_err();
         assert!(matches!(err, AlkTypeError::Access { .. }), "got {err:?}");
     }
 
     #[test]
     fn rejects_non_struct_top_level() {
-        let schema = json!({ "AlkType:Uint32": true });
-        let err = SequentialReader::new(&schema).unwrap_err();
-        assert!(matches!(err, AlkTypeError::Schema(_)), "got {err:?}");
-    }
-
-    #[test]
-    fn rejects_schema_without_alktype_kind() {
-        let schema = json!({ "type": "object", "properties": {} });
-        let err = SequentialReader::new(&schema).unwrap_err();
+        let root = json!({
+            "$defs": {
+                "U": { "kind": "uint32" }
+            }
+        });
+        let err = SequentialReader::new(&root, "U").unwrap_err();
         assert!(matches!(err, AlkTypeError::Schema(_)), "got {err:?}");
     }
 
     #[test]
     fn reads_all_fixed_size_kinds() {
-        let schema = json!({
-            "AlkType:Struct": true,
-            "properties": {
-                "i8":  { "AlkType:Int8": true },
-                "i16": { "AlkType:Int16": true },
-                "i32": { "AlkType:Int32": true },
-                "i64": { "AlkType:Int64": true },
-                "u8":  { "AlkType:Uint8": true },
-                "u16": { "AlkType:Uint16": true },
-                "u32": { "AlkType:Uint32": true },
-                "u64": { "AlkType:Uint64": true },
-                "f32": { "AlkType:Float32": true },
-                "f64": { "AlkType:Float64": true },
-                "b":   { "AlkType:Boolean": true },
-                "e":   { "AlkType:Enum": true }
+        let root = json!({
+            "$defs": {
+                "S": {
+                    "kind": "struct",
+                    "fields": [
+                        { "name": "i8",  "kind": "int8" },
+                        { "name": "i16", "kind": "int16" },
+                        { "name": "i32", "kind": "int32" },
+                        { "name": "i64", "kind": "int64" },
+                        { "name": "u8",  "kind": "uint8" },
+                        { "name": "u16", "kind": "uint16" },
+                        { "name": "u32", "kind": "uint32" },
+                        { "name": "u64", "kind": "uint64" },
+                        { "name": "f32", "kind": "float32" },
+                        { "name": "f64", "kind": "float64" },
+                        { "name": "b",   "kind": "bool" },
+                        { "name": "e",   "kind": { "$ref": "#/$defs/E" } }
+                    ]
+                },
+                "E": { "kind": "enum", "values": ["A", "B"] }
             }
         });
         let mut buf = vec![0u8; 80];
@@ -1103,7 +1138,7 @@ mod tests {
         buf[42] = 0x01;
         buf[43..47].copy_from_slice(&7u32.to_le_bytes());
 
-        let mut reader = SequentialReader::new(&schema).unwrap();
+        let mut reader = reader(&root, "S");
         let (_, v) = reader.read_next(&buf).unwrap().unwrap();
         assert_eq!(v, FieldValue::I8(-128));
         let (_, v) = reader.read_next(&buf).unwrap().unwrap();
@@ -1133,17 +1168,24 @@ mod tests {
 
     #[test]
     fn nested_struct_reports_byte_range() {
-        let nested = json!({
-            "AlkType:Struct": true,
-            "properties": {
-                "inner": {
-                    "AlkType:Struct": true,
-                    "properties": {
-                        "x": { "AlkType:Uint8": true },
-                        "y": { "AlkType:Uint16": true }
-                    }
-                },
-                "tail": { "AlkType:Uint8": true }
+        let root = json!({
+            "$defs": {
+                "S": {
+                    "kind": "struct",
+                    "fields": [
+                        {
+                            "name": "inner",
+                            "kind": {
+                                "kind": "struct",
+                                "fields": [
+                                    { "name": "x", "kind": "uint8" },
+                                    { "name": "y", "kind": "uint16" }
+                                ]
+                            }
+                        },
+                        { "name": "tail", "kind": "uint8" }
+                    ]
+                }
             }
         });
         let mut buf = vec![0u8; 16];
@@ -1151,19 +1193,13 @@ mod tests {
         buf[1..3].copy_from_slice(&0x0203u16.to_le_bytes());
         buf[3] = 9;
 
-        let mut reader = SequentialReader::new(&nested).unwrap();
+        let mut reader = reader(&root, "S");
         let (name, value) = reader.read_next(&buf).unwrap().unwrap();
         assert_eq!(name, "inner");
         match value {
             FieldValue::Struct { start, end } => {
                 assert_eq!(start, 0);
                 assert_eq!(end, 3);
-                let inner_schema = &nested["properties"]["inner"];
-                let inner_reader = SequentialReader::new(inner_schema).unwrap();
-                let inner_end =
-                    walk_struct_size(inner_schema, inner_schema, &buf, start, LE).unwrap();
-                assert_eq!(inner_end, end - start);
-                let _ = inner_reader;
             }
             other => panic!("expected Struct, got {other:?}"),
         }
@@ -1177,20 +1213,27 @@ mod tests {
 
     #[test]
     fn byte_discriminator_union_reads_value() {
-        let variant = json!({
-            "AlkType:Struct": true,
-            "properties": {
-                "x": { "AlkType:Uint8": true }
-            }
-        });
-        let schema = json!({
-            "AlkType:Struct": true,
-            "properties": {
-                "packet": {
-                    "AlkType:Union": true,
-                    "discriminator": { "kind": "byte", "offset": 0, "type": "AlkType:Uint8" },
-                    "mapping": { "5": variant.clone() },
-                    "$defs": { "Read": variant.clone() }
+        let root = json!({
+            "$defs": {
+                "S": {
+                    "kind": "struct",
+                    "fields": [
+                        {
+                            "name": "packet",
+                            "kind": { "$ref": "#/$defs/Packet" }
+                        }
+                    ]
+                },
+                "Packet": {
+                    "kind": "union",
+                    "discriminator": { "kind": "byte", "offset": 0, "type": "uint8" },
+                    "mapping": {
+                        "5": { "$ref": "#/$defs/Read" }
+                    }
+                },
+                "Read": {
+                    "kind": "struct",
+                    "fields": [ { "name": "x", "kind": "uint8" } ]
                 }
             }
         });
@@ -1198,7 +1241,7 @@ mod tests {
         buf[0] = 5;
         buf[1] = 42;
 
-        let mut reader = SequentialReader::new(&schema).unwrap();
+        let mut reader = reader(&root, "S");
         let (name, value) = reader.read_next(&buf).unwrap().unwrap();
         assert_eq!(name, "packet");
         match value {
@@ -1216,22 +1259,28 @@ mod tests {
 
     #[test]
     fn field_discriminator_union_reads_value() {
-        let variant = json!({
-            "AlkType:Struct": true,
-            "properties": {
-                "payload": { "AlkType:Uint8": true }
-            }
-        });
-        let schema = json!({
-            "AlkType:Struct": true,
-            "properties": {
-                "event": {
-                    "AlkType:Union": true,
+        let root = json!({
+            "$defs": {
+                "S": {
+                    "kind": "struct",
+                    "fields": [
+                        {
+                            "name": "event",
+                            "kind": { "$ref": "#/$defs/Event" }
+                        }
+                    ]
+                },
+                "Event": {
+                    "kind": "union",
                     "discriminator": { "kind": "field", "name": "type" },
-                    "properties": {
-                        "type": { "AlkType:String": true }
-                    },
-                    "mapping": { "read": variant.clone() }
+                    "fields": [ { "name": "type", "kind": "string" } ],
+                    "mapping": {
+                        "read": { "$ref": "#/$defs/Read" }
+                    }
+                },
+                "Read": {
+                    "kind": "struct",
+                    "fields": [ { "name": "payload", "kind": "uint8" } ]
                 }
             }
         });
@@ -1240,7 +1289,7 @@ mod tests {
         let after = written;
         buf[after] = 7;
 
-        let mut reader = SequentialReader::new(&schema).unwrap();
+        let mut reader = reader(&root, "S");
         let (name, value) = reader.read_next(&buf).unwrap().unwrap();
         assert_eq!(name, "event");
         match value {
@@ -1258,20 +1307,22 @@ mod tests {
 
     #[test]
     fn fixed_count_array_reads_count_inline() {
-        let schema = json!({
-            "AlkType:Struct": true,
-            "properties": {
-                "vals": {
-                    "AlkType:Array": true,
-                    "minItems": 3,
-                    "maxItems": 3,
-                    "items": { "AlkType:Uint8": true }
+        let root = json!({
+            "$defs": {
+                "S": {
+                    "kind": "struct",
+                    "fields": [
+                        {
+                            "name": "vals",
+                            "kind": { "kind": "array", "element": "uint8", "count": 3 }
+                        }
+                    ]
                 }
             }
         });
         let buf = [1u8, 2, 3];
 
-        let mut reader = SequentialReader::new(&schema).unwrap();
+        let mut reader = reader(&root, "S");
         let (name, value) = reader.read_next(&buf).unwrap().unwrap();
         assert_eq!(name, "vals");
         match value {
@@ -1289,58 +1340,27 @@ mod tests {
         assert_eq!(reader.position(), 3);
     }
 
-    #[test]
-    fn variable_count_array_reads_count_prefix() {
-        let schema = json!({
-            "AlkType:Struct": true,
-            "properties": {
-                "vals": {
-                    "AlkType:Array": true,
-                    "items": { "AlkType:Uint16": true }
-                }
-            }
-        });
-        let mut buf = vec![0u8; 16];
-        write_u32(&mut buf, 0, 2, LE);
-        buf[4..6].copy_from_slice(&100u16.to_le_bytes());
-        buf[6..8].copy_from_slice(&200u16.to_le_bytes());
-
-        let mut reader = SequentialReader::new(&schema).unwrap();
-        let (name, value) = reader.read_next(&buf).unwrap().unwrap();
-        assert_eq!(name, "vals");
-        match value {
-            FieldValue::Array {
-                count,
-                element_start,
-                element_stride,
-            } => {
-                assert_eq!(count, 2);
-                assert_eq!(element_start, 4);
-                assert_eq!(element_stride, 2);
-            }
-            other => panic!("expected Array, got {other:?}"),
-        }
-        assert_eq!(reader.position(), 8);
-    }
-
     #[test]
     fn variable_length_element_array_walks_sequentially() {
-        let schema = json!({
-            "AlkType:Struct": true,
-            "properties": {
-                "items": {
-                    "AlkType:Array": true,
-                    "items": { "AlkType:String": true }
+        let root = json!({
+            "$defs": {
+                "S": {
+                    "kind": "struct",
+                    "fields": [
+                        {
+                            "name": "items",
+                            "kind": { "kind": "array", "element": "string", "count": 2 }
+                        }
+                    ]
                 }
             }
         });
         let mut buf = vec![0u8; 64];
-        write_u32(&mut buf, 0, 2, LE);
-        let mut pos = 4;
+        let mut pos = 0;
         pos += write_string(&mut buf, pos, "ab", LE);
         pos += write_string(&mut buf, pos, "cdef", LE);
 
-        let mut reader = SequentialReader::new(&schema).unwrap();
+        let mut reader = reader(&root, "S");
         let (name, value) = reader.read_next(&buf).unwrap().unwrap();
         assert_eq!(name, "items");
         match value {
@@ -1350,7 +1370,7 @@ mod tests {
                 element_stride,
             } => {
                 assert_eq!(count, 2);
-                assert_eq!(element_start, 4);
+                assert_eq!(element_start, 0);
                 assert_eq!(element_stride, 0);
             }
             other => panic!("expected Array, got {other:?}"),
@@ -1360,17 +1380,19 @@ mod tests {
 
     #[test]
     fn timestamp_field_reads_as_length_prefixed_string() {
-        let schema = json!({
-            "AlkType:Struct": true,
-            "properties": {
-                "ts": { "AlkType:Timestamp": true }
+        let root = json!({
+            "$defs": {
+                "S": {
+                    "kind": "struct",
+                    "fields": [ { "name": "ts", "kind": "timestamp" } ]
+                }
             }
         });
         let mut buf = vec![0u8; 64];
         let stamp = "2026-07-20T15:30:00Z";
         let written = write_string(&mut buf, 0, stamp, LE);
 
-        let mut reader = SequentialReader::new(&schema).unwrap();
+        let mut reader = reader(&root, "S");
         let (name, value) = reader.read_next(&buf).unwrap().unwrap();
         assert_eq!(name, "ts");
         assert_eq!(value, FieldValue::String(stamp));
@@ -1379,12 +1401,16 @@ mod tests {
 
     #[test]
     fn record_field_walks_entries() {
-        let schema = json!({
-            "AlkType:Struct": true,
-            "properties": {
-                "counts": {
-                    "AlkType:Record": true,
-                    "values": { "AlkType:Uint32": true }
+        let root = json!({
+            "$defs": {
+                "S": {
+                    "kind": "struct",
+                    "fields": [
+                        {
+                            "name": "counts",
+                            "kind": { "kind": "record", "values": "uint32" }
+                        }
+                    ]
                 }
             }
         });
@@ -1398,7 +1424,7 @@ mod tests {
         buf[pos..pos + 4].copy_from_slice(&2u32.to_le_bytes());
         pos += 4;
 
-        let mut reader = SequentialReader::new(&schema).unwrap();
+        let mut reader = reader(&root, "S");
         let (name, _value) = reader.read_next(&buf).unwrap().unwrap();
         assert_eq!(name, "counts");
         assert_eq!(reader.position(), pos);
@@ -1406,150 +1432,40 @@ mod tests {
 
     #[test]
     fn union_unknown_discriminator_returns_access_error() {
-        let variant = json!({
-            "AlkType:Struct": true,
-            "properties": { "x": { "AlkType:Uint8": true } }
-        });
-        let schema = json!({
-            "AlkType:Struct": true,
-            "properties": {
-                "packet": {
-                    "AlkType:Union": true,
-                    "discriminator": { "kind": "byte", "offset": 0, "type": "AlkType:Uint8" },
-                    "mapping": { "5": variant },
-                    "$defs": { "Read": variant }
+        let root = json!({
+            "$defs": {
+                "S": {
+                    "kind": "struct",
+                    "fields": [
+                        {
+                            "name": "packet",
+                            "kind": { "$ref": "#/$defs/Packet" }
+                        }
+                    ]
+                },
+                "Packet": {
+                    "kind": "union",
+                    "discriminator": { "kind": "byte", "offset": 0, "type": "uint8" },
+                    "mapping": {
+                        "5": { "$ref": "#/$defs/Read" }
+                    }
+                },
+                "Read": {
+                    "kind": "struct",
+                    "fields": [ { "name": "x", "kind": "uint8" } ]
                 }
             }
         });
         let buf = [99u8, 0];
-        let mut reader = SequentialReader::new(&schema).unwrap();
+        let mut reader = reader(&root, "S");
         let err = reader.read_next(&buf).unwrap_err();
         assert!(matches!(err, AlkTypeError::Access { .. }), "got {err:?}");
     }
 
     #[test]
-    fn union_via_ref_resolves_variant() {
-        let read_variant = json!({
-            "AlkType:Struct": true,
-            "properties": { "len": { "AlkType:Uint32": true } }
-        });
-        let schema = json!({
-            "AlkType:Struct": true,
-            "$defs": { "Read": read_variant },
-            "properties": {
-                "packet": {
-                    "AlkType:Union": true,
-                    "discriminator": { "kind": "byte", "offset": 0, "type": "AlkType:Uint8" },
-                    "mapping": { "5": { "$ref": "#/$defs/Read" } }
-                }
-            }
-        });
-        let mut buf = vec![0u8; 16];
-        buf[0] = 5;
-        write_u32(&mut buf, 1, 1234, LE);
-
-        let mut reader = SequentialReader::new(&schema).unwrap();
-        let (name, value) = reader.read_next(&buf).unwrap().unwrap();
-        assert_eq!(name, "packet");
-        match value {
-            FieldValue::Union {
-                discriminator,
-                variant_start,
-            } => {
-                assert_eq!(discriminator, "5");
-                assert_eq!(variant_start, 1);
-            }
-            other => panic!("expected Union, got {other:?}"),
-        }
-        assert_eq!(reader.position(), 5);
+    fn rejects_schema_with_missing_root() {
+        let root = json!({ "$defs": { "Other": { "kind": "struct", "fields": [] } } });
+        let err = SequentialReader::new(&root, "Missing").unwrap_err();
+        assert!(matches!(err, AlkTypeError::Schema(_)), "got {err:?}");
     }
-
-    #[test]
-    fn union_via_ref_with_local_defs_resolves_variant() {
-        let read_variant = json!({
-            "AlkType:Struct": true,
-            "properties": { "len": { "AlkType:Uint32": true } }
-        });
-        let schema = json!({
-            "AlkType:Struct": true,
-            "properties": {
-                "packet": {
-                    "AlkType:Union": true,
-                    "discriminator": { "kind": "byte", "offset": 0, "type": "AlkType:Uint8" },
-                    "mapping": { "5": { "$ref": "#/$defs/Read" } },
-                    "$defs": { "Read": read_variant }
-                }
-            }
-        });
-        let mut buf = vec![0u8; 16];
-        buf[0] = 5;
-        write_u32(&mut buf, 1, 1234, LE);
-
-        let mut reader = SequentialReader::new(&schema).unwrap();
-        let (name, value) = reader.read_next(&buf).unwrap().unwrap();
-        assert_eq!(name, "packet");
-        match value {
-            FieldValue::Union {
-                discriminator,
-                variant_start,
-            } => {
-                assert_eq!(discriminator, "5");
-                assert_eq!(variant_start, 1);
-            }
-            other => panic!("expected Union, got {other:?}"),
-        }
-        assert_eq!(reader.position(), 5);
-    }
-
-    #[test]
-    fn empty_struct_returns_none_immediately() {
-        let schema = json!({
-            "AlkType:Struct": true,
-            "properties": {}
-        });
-        let buf = [];
-        let mut reader = SequentialReader::new(&schema).unwrap();
-        assert!(reader.read_next(&buf).unwrap().is_none());
-        assert_eq!(reader.position(), 0);
-    }
-
-    #[test]
-    fn nested_struct_with_variable_field_computes_end() {
-        let nested = json!({
-            "AlkType:Struct": true,
-            "properties": {
-                "header": {
-                    "AlkType:Struct": true,
-                    "properties": {
-                        "id": { "AlkType:Uint8": true },
-                        "name": { "AlkType:String": true }
-                    }
-                },
-                "tail": { "AlkType:Uint8": true }
-            }
-        });
-        let mut buf = vec![0u8; 64];
-        buf[0] = 1;
-        let written = write_string(&mut buf, 1, "abc", LE);
-        let header_end = 1 + written;
-        buf[header_end] = 7;
-        let expected_end = header_end + 1;
-
-        let mut reader = SequentialReader::new(&nested).unwrap();
-        let (name, value) = reader.read_next(&buf).unwrap().unwrap();
-        assert_eq!(name, "header");
-        match value {
-            FieldValue::Struct { start, end } => {
-                assert_eq!(start, 0);
-                assert_eq!(end, header_end);
-            }
-            other => panic!("expected Struct, got {other:?}"),
-        }
-        assert_eq!(reader.position(), header_end);
-
-        let (name, value) = reader.read_next(&buf).unwrap().unwrap();
-        assert_eq!(name, "tail");
-        assert_eq!(value, FieldValue::U8(7));
-        assert_eq!(reader.position(), expected_end);
-    }
-}
+}
\ No newline at end of file
diff --git a/src/tunion.rs b/src/tunion.rs
index 4d17e5d..71112e7 100644
--- a/src/tunion.rs
+++ b/src/tunion.rs
@@ -3,16 +3,16 @@
 //! TUnion supports two discriminator kinds: byte-offset (protocol
 //! dispatch, e.g., SFTP type bytes) and field-name (typedef.ts string
 //! pattern). This module reads the discriminator value from a byte
-//! buffer, looks up the variant schema in the union's `mapping`, and
+//! buffer, looks up the variant type in the union's `mapping`, and
 //! reports the offset where the variant struct begins.
 //!
 //! All reads go through [`crate::data_access`] so bounds checks and
 //! endianness handling are uniform with the rest of the engine.
 
+use crate::bast::{BastDiscriminator, BastType, BastUnion};
 use crate::data_access::{read_enum, read_string, read_u16, read_u32, read_u8};
 use crate::error::AlkTypeError;
-use crate::schema::{get_alktype_kind, parse_discriminator, DiscriminatorKind, Endian, AlkTypeKind, DISCRIMINATOR_PATH, U32_SIZE};
-use serde_json::Value;
+use crate::schema::{AlkTypeKind, Endian, DISCRIMINATOR_PATH, U32_SIZE};
 
 const STRING_PREFIX_SIZE: usize = 4;
 
@@ -39,21 +39,19 @@ pub struct UnionDispatch {
 ///
 /// # Errors
 ///
-/// - [`AlkTypeError::Schema`] if the discriminator annotation is missing
-///   or malformed, or if the discriminator `type` is not one of
-///   `AlkType:Uint8` / `AlkType:Uint16` / `AlkType:Uint32`.
+/// - [`AlkTypeError::Schema`] if the union does not have a byte-offset
+///   discriminator.
 /// - [`AlkTypeError::Access`] if the buffer is too short to contain the
 ///   discriminator, or if the read value is not present in the union's
 ///   `mapping`.
 pub fn read_byte_discriminator(
     buffer: &[u8],
-    union_schema: &Value,
+    union_node: &BastUnion<'_>,
     endian: Endian,
 ) -> Result<UnionDispatch, AlkTypeError> {
-    let disc = parse_discriminator(union_schema)?;
-    let (offset, disc_type) = match disc {
-        DiscriminatorKind::Byte { offset, disc_type } => (offset, disc_type),
-        DiscriminatorKind::Field { .. } => {
+    let (offset, disc_type) = match union_node.discriminator() {
+        BastDiscriminator::Byte { offset, disc_type } => (*offset, *disc_type),
+        BastDiscriminator::Field { .. } => {
             return Err(AlkTypeError::Schema(
                 "read_byte_discriminator requires a byte-offset discriminator".to_string(),
             ));
@@ -75,7 +73,7 @@ pub fn read_byte_discriminator(
     };
 
     let key = disc_value.to_string();
-    verify_mapping_key(union_schema, &key, DISCRIMINATOR_PATH, &key)?;
+    verify_mapping_key(union_node, &key, DISCRIMINATOR_PATH, &key)?;
 
     let variant_offset =
         offset
@@ -105,56 +103,44 @@ pub fn read_byte_discriminator(
 ///
 /// # Errors
 ///
-/// - [`AlkTypeError::Schema`] if the discriminator annotation is missing
-///   or malformed, the discriminator field is not declared in
-///   `properties`, the field has no `AlkType:*` kind, or the field's
-///   kind is not one of `AlkType:String` / `AlkType:Uint8` /
-///   `AlkType:Enum`.
+/// - [`AlkTypeError::Schema`] if the union does not have a field-name
+///   discriminator, the discriminator field is not declared in
+///   `fields`, or the field's kind is not one of `string` / `uint8` /
+///   `enum`.
 /// - [`AlkTypeError::Access`] if the buffer is too short to contain the
 ///   discriminator field, or if the read value is not present in the
 ///   union's `mapping`.
 pub fn read_field_discriminator(
     buffer: &[u8],
-    union_schema: &Value,
+    union_node: &BastUnion<'_>,
     disc_field_offset: usize,
     endian: Endian,
 ) -> Result<UnionDispatch, AlkTypeError> {
-    let disc = parse_discriminator(union_schema)?;
-    let name = match disc {
-        DiscriminatorKind::Field { name } => name,
-        DiscriminatorKind::Byte { .. } => {
+    let name = match union_node.discriminator() {
+        BastDiscriminator::Field { name } => *name,
+        BastDiscriminator::Byte { .. } => {
             return Err(AlkTypeError::Schema(
                 "read_field_discriminator requires a field-name discriminator".to_string(),
             ));
         }
     };
 
-    let field_schema = union_schema
-        .get("properties")
-        .and_then(Value::as_object)
-        .and_then(|props| props.get(&name))
-        .ok_or_else(|| {
-            AlkTypeError::Schema(format!(
-                "discriminator field '{name}' not found in union properties"
-            ))
-        })?;
+    let disc_field = union_node.fields().iter().find(|f| f.name() == name).ok_or_else(|| {
+        AlkTypeError::Schema(format!(
+            "discriminator field '{name}' not found in union fields"
+        ))
+    })?;
 
-    let kind = get_alktype_kind(field_schema)
-        .and_then(|s| s.parse::<AlkTypeKind>().ok())
-        .ok_or_else(|| {
-            AlkTypeError::Schema(format!(
-                "discriminator field '{name}' has no AlkType:* kind"
-            ))
-        })?;
+    let kind = disc_field.ty().alk_kind();
 
     let (key, discriminator_field_size) = match kind {
         AlkTypeKind::String => {
-            let s = read_string(buffer, disc_field_offset, &name, endian)?;
+            let s = read_string(buffer, disc_field_offset, name, endian)?;
             let size =
                 STRING_PREFIX_SIZE
                     .checked_add(s.len())
                     .ok_or_else(|| AlkTypeError::Access {
-                        field_path: name.clone(),
+                        field_path: name.to_string(),
                         reason: format!(
                             "string prefix {STRING_PREFIX_SIZE} + data length {} overflows usize",
                             s.len()
@@ -163,11 +149,11 @@ pub fn read_field_discriminator(
             (s.to_string(), size)
         }
         AlkTypeKind::Uint8 => {
-            let v = read_u8(buffer, disc_field_offset, &name)?;
+            let v = read_u8(buffer, disc_field_offset, name)?;
             (v.to_string(), 1)
         }
         AlkTypeKind::Enum => {
-            let v = read_enum(buffer, disc_field_offset, &name, endian)?;
+            let v = read_enum(buffer, disc_field_offset, name, endian)?;
             (v.to_string(), U32_SIZE)
         }
         other => {
@@ -177,12 +163,12 @@ pub fn read_field_discriminator(
         }
     };
 
-    verify_mapping_key(union_schema, &key, &name, &key)?;
+    verify_mapping_key(union_node, &key, name, &key)?;
 
     let variant_offset = disc_field_offset
         .checked_add(discriminator_field_size)
         .ok_or_else(|| AlkTypeError::Access {
-            field_path: name.clone(),
+            field_path: name.to_string(),
             reason: format!(
                 "disc_field_offset {disc_field_offset} + discriminator_field_size {discriminator_field_size} overflows usize"
             ),
@@ -195,63 +181,39 @@ pub fn read_field_discriminator(
     })
 }
 
-/// Look up a variant schema from the union's mapping.
+/// Look up a variant type from the union's mapping.
 ///
-/// Returns the variant schema. Inline schemas are returned directly.
-/// `$ref` pointers of the form `"#/$defs/<name>"` are resolved against
-/// the `union_schema`'s own `$defs` block (when the union schema is the
-/// schema root). For nested unions whose `$defs` live on an ancestor,
-/// the caller (typically `AlkTypeEngine::compile`) is expected to
-/// resolve refs before reaching this function, or to inline the
-/// variant schemas into the mapping at load time.
+/// Returns the variant [`BastType`]. Inline struct/union/enum types are
+/// returned directly; `$ref` pointers are returned as
+/// [`BastType::Ref`] — the caller resolves them via
+/// [`crate::bast::BastDoc::resolve_typeref`] when a concrete definition is needed.
 ///
 /// # Errors
 ///
-/// - [`AlkTypeError::Schema`] if the union has no `mapping` object, the
-///   `key` is not present, a `$ref` is malformed, or a `$ref` cannot be
-///   resolved against the union schema's own `$defs`.
-pub fn resolve_variant<'a>(union_schema: &'a Value, key: &str) -> Result<&'a Value, AlkTypeError> {
-    let mapping = union_schema
-        .get("mapping")
-        .and_then(Value::as_object)
-        .ok_or_else(|| AlkTypeError::Schema("union is missing 'mapping' object".to_string()))?;
-
-    let variant = mapping
-        .get(key)
-        .ok_or_else(|| AlkTypeError::Schema(format!("unknown mapping key: {key}")))?;
-
-    let ref_str = match variant.get("$ref").and_then(Value::as_str) {
-        Some(r) => r,
-        None => return Ok(variant),
-    };
-
-    let pointer = ref_str
-        .strip_prefix('#')
-        .ok_or_else(|| AlkTypeError::Schema(format!("unsupported $ref form: {ref_str}")))?;
-
-    let resolved = resolve_json_pointer(union_schema, pointer).ok_or_else(|| {
-        AlkTypeError::Schema(format!(
-            "cannot resolve $ref {ref_str} against union schema; ensure refs are inlined or the union schema contains $defs"
-        ))
-    })?;
-    Ok(resolved)
+/// - [`AlkTypeError::Schema`] if the union has no `mapping` entries or
+///   the `key` is not present.
+pub fn resolve_variant<'a>(
+    union_node: &'a BastUnion<'a>,
+    key: &str,
+) -> Result<&'a BastType<'a>, AlkTypeError> {
+    union_node
+        .variant_for(key)
+        .ok_or_else(|| AlkTypeError::Schema(format!("unknown mapping key: {key}")))
 }
 
 /// Get the discriminator size in bytes for a byte-offset discriminator.
 ///
-/// Returns 1 for `AlkType:Uint8`, 2 for `AlkType:Uint16`, and 4 for
-/// `AlkType:Uint32`. Field-name discriminators have no fixed size and
-/// produce a [`AlkTypeError::Schema`].
+/// Returns 1 for `uint8`, 2 for `uint16`, and 4 for `uint32`.
+/// Field-name discriminators have no fixed size and produce a
+/// [`AlkTypeError::Schema`].
 ///
 /// # Errors
 ///
-/// - [`AlkTypeError::Schema`] if the discriminator annotation is
-///   missing/malformed, the discriminator `type` is unsupported, or the
-///   discriminator is a field-name discriminator.
-pub fn discriminator_size(union_schema: &Value) -> Result<usize, AlkTypeError> {
-    let disc = parse_discriminator(union_schema)?;
-    match disc {
-        DiscriminatorKind::Byte { disc_type, .. } => match disc_type {
+/// - [`AlkTypeError::Schema`] if the discriminator is a field-name
+///   discriminator.
+pub fn discriminator_size(union_node: &BastUnion<'_>) -> Result<usize, AlkTypeError> {
+    match union_node.discriminator() {
+        BastDiscriminator::Byte { disc_type, .. } => match disc_type {
             AlkTypeKind::Uint8 => Ok(1),
             AlkTypeKind::Uint16 => Ok(2),
             AlkTypeKind::Uint32 => Ok(4),
@@ -259,24 +221,19 @@ pub fn discriminator_size(union_schema: &Value) -> Result<usize, AlkTypeError> {
                 "unsupported byte discriminator type: {other}"
             ))),
         },
-        DiscriminatorKind::Field { .. } => Err(AlkTypeError::Schema(
+        BastDiscriminator::Field { .. } => Err(AlkTypeError::Schema(
             "field-name discriminator has no fixed size".to_string(),
         )),
     }
 }
 
 fn verify_mapping_key(
-    union_schema: &Value,
+    union_node: &BastUnion<'_>,
     key: &str,
     field_path: &str,
     raw_value: &str,
 ) -> Result<(), AlkTypeError> {
-    let in_mapping = union_schema
-        .get("mapping")
-        .and_then(Value::as_object)
-        .map(|m| m.contains_key(key))
-        .unwrap_or(false);
-    if in_mapping {
+    if union_node.variant_for(key).is_some() {
         Ok(())
     } else {
         Err(AlkTypeError::Access {
@@ -286,84 +243,64 @@ fn verify_mapping_key(
     }
 }
 
-fn resolve_json_pointer<'a>(root: &'a Value, pointer: &str) -> Option<&'a Value> {
-    if pointer.is_empty() {
-        return Some(root);
-    }
-    let trimmed = pointer.strip_prefix('/')?;
-    let mut current = root;
-    for unescaped in trimmed.split('/') {
-        let segment = unescape_json_pointer_token(unescaped)?;
-        current = current.get(&segment)?;
-    }
-    Some(current)
-}
-
-fn unescape_json_pointer_token(token: &str) -> Option<String> {
-    let mut out = String::with_capacity(token.len());
-    let mut chars = token.chars();
-    while let Some(c) = chars.next() {
-        match c {
-            '~' => match chars.next() {
-                Some('0') => out.push('~'),
-                Some('1') => out.push('/'),
-                _ => return None,
-            },
-            other => out.push(other),
-        }
-    }
-    Some(out)
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;
+    use crate::bast::BastDoc;
     use serde_json::json;
 
     const LE: Endian = Endian::Little;
     const BE: Endian = Endian::Big;
 
-    fn byte_union_schema(offset: usize, disc_type: &str) -> Value {
+    fn doc_union<'a>(root: &'a serde_json::Value, name: &'a str) -> BastUnion<'a> {
+        let doc = BastDoc::new(root, name).expect("bast doc");
+        match doc.root_def().kind() {
+            crate::bast::BastDefKind::Union(u) => u.clone(),
+            _ => panic!("root must be a union"),
+        }
+    }
+
+    fn byte_union_root(offset: usize, disc_type: &str) -> serde_json::Value {
         json!({
-            "AlkType:Union": true,
-            "discriminator": {"kind": "byte", "offset": offset, "type": disc_type},
-            "mapping": {
-                "5": {"AlkType:Struct": true, "properties": {"id": {"AlkType:Uint32": true}}},
-                "6": {"AlkType:Struct": true, "properties": {"len": {"AlkType:Uint16": true}}}
+            "$defs": {
+                "U": {
+                    "kind": "union",
+                    "discriminator": { "kind": "byte", "offset": offset, "type": disc_type },
+                    "mapping": {
+                        "5": { "kind": "struct", "fields": [ { "name": "id", "kind": "uint32" } ] },
+                        "6": { "kind": "struct", "fields": [ { "name": "len", "kind": "uint16" } ] }
+                    }
+                }
             }
         })
     }
 
-    fn field_union_schema(field_name: &str, field_kind: &str) -> Value {
-        let field_schema = match field_kind {
-            "AlkType:Enum" => json!({
-                "AlkType:Enum": true,
-                "enum": ["read", "write"]
-            }),
-            _ => json!({field_kind: true}),
-        };
+    fn field_union_root(field_name: &str, field_kind: &str) -> serde_json::Value {
         let (key_a, key_b) = match field_kind {
-            "AlkType:String" => ("read", "write"),
+            "string" => ("read", "write"),
             _ => ("0", "1"),
         };
         json!({
-            "AlkType:Union": true,
-            "discriminator": {"kind": "field", "name": field_name},
-            "properties": {
-                field_name: field_schema
-            },
-            "mapping": {
-                key_a: {"AlkType:Struct": true, "properties": {"n": {"AlkType:Uint32": true}}},
-                key_b: {"AlkType:Struct": true, "properties": {"m": {"AlkType:Uint16": true}}}
+            "$defs": {
+                "U": {
+                    "kind": "union",
+                    "discriminator": { "kind": "field", "name": field_name },
+                    "fields": [ { "name": field_name, "kind": field_kind } ],
+                    "mapping": {
+                        key_a: { "kind": "struct", "fields": [ { "name": "n", "kind": "uint32" } ] },
+                        key_b: { "kind": "struct", "fields": [ { "name": "m", "kind": "uint16" } ] }
+                    }
+                }
             }
         })
     }
 
     #[test]
     fn read_byte_discriminator_uint8_default_offset() {
-        let schema = byte_union_schema(0, "AlkType:Uint8");
+        let root = byte_union_root(0, "uint8");
+        let u = doc_union(&root, "U");
         let buf = [5u8, 0xAA, 0xBB, 0xCC];
-        let d = read_byte_discriminator(&buf, &schema, LE).expect("read");
+        let d = read_byte_discriminator(&buf, &u, LE).expect("read");
         assert_eq!(d.key, "5");
         assert_eq!(d.variant_offset, 1);
         assert_eq!(d.discriminator_size, 1);
@@ -371,19 +308,21 @@ mod tests {
 
     #[test]
     fn read_byte_discriminator_uint8_big_endian() {
-        let schema = byte_union_schema(0, "AlkType:Uint8");
+        let root = byte_union_root(0, "uint8");
+        let u = doc_union(&root, "U");
         let buf = [6u8];
-        let d = read_byte_discriminator(&buf, &schema, BE).expect("read");
+        let d = read_byte_discriminator(&buf, &u, BE).expect("read");
         assert_eq!(d.key, "6");
         assert_eq!(d.variant_offset, 1);
     }
 
     #[test]
     fn read_byte_discriminator_uint16_little_endian() {
-        let schema = byte_union_schema(2, "AlkType:Uint16");
+        let root = byte_union_root(2, "uint16");
+        let u = doc_union(&root, "U");
         let mut buf = vec![0u8; 4];
         buf[2..4].copy_from_slice(&5u16.to_le_bytes());
-        let d = read_byte_discriminator(&buf, &schema, LE).expect("read");
+        let d = read_byte_discriminator(&buf, &u, LE).expect("read");
         assert_eq!(d.key, "5");
         assert_eq!(d.variant_offset, 4);
         assert_eq!(d.discriminator_size, 2);
@@ -391,19 +330,21 @@ mod tests {
 
     #[test]
     fn read_byte_discriminator_uint16_big_endian() {
-        let schema = byte_union_schema(0, "AlkType:Uint16");
+        let root = byte_union_root(0, "uint16");
+        let u = doc_union(&root, "U");
         let buf = [0x00, 0x06, 0xAA, 0xBB];
-        let d = read_byte_discriminator(&buf, &schema, BE).expect("read");
+        let d = read_byte_discriminator(&buf, &u, BE).expect("read");
         assert_eq!(d.key, "6");
         assert_eq!(d.variant_offset, 2);
     }
 
     #[test]
     fn read_byte_discriminator_uint32_little_endian() {
-        let schema = byte_union_schema(0, "AlkType:Uint32");
+        let root = byte_union_root(0, "uint32");
+        let u = doc_union(&root, "U");
         let mut buf = vec![0u8; 8];
         buf[0..4].copy_from_slice(&5u32.to_le_bytes());
-        let d = read_byte_discriminator(&buf, &schema, LE).expect("read");
+        let d = read_byte_discriminator(&buf, &u, LE).expect("read");
         assert_eq!(d.key, "5");
         assert_eq!(d.variant_offset, 4);
         assert_eq!(d.discriminator_size, 4);
@@ -411,19 +352,21 @@ mod tests {
 
     #[test]
     fn read_byte_discriminator_uint32_big_endian() {
-        let schema = byte_union_schema(0, "AlkType:Uint32");
+        let root = byte_union_root(0, "uint32");
+        let u = doc_union(&root, "U");
         let mut buf = vec![0u8; 8];
         buf[0..4].copy_from_slice(&6u32.to_be_bytes());
-        let d = read_byte_discriminator(&buf, &schema, BE).expect("read");
+        let d = read_byte_discriminator(&buf, &u, BE).expect("read");
         assert_eq!(d.key, "6");
         assert_eq!(d.variant_offset, 4);
     }
 
     #[test]
     fn read_byte_discriminator_unknown_value_is_access_error() {
-        let schema = byte_union_schema(0, "AlkType:Uint8");
+        let root = byte_union_root(0, "uint8");
+        let u = doc_union(&root, "U");
         let buf = [99u8];
-        let err = read_byte_discriminator(&buf, &schema, LE).unwrap_err();
+        let err = read_byte_discriminator(&buf, &u, LE).unwrap_err();
         match err {
             AlkTypeError::Access { field_path, reason } => {
                 assert_eq!(field_path, DISCRIMINATOR_PATH);
@@ -435,29 +378,32 @@ mod tests {
 
     #[test]
     fn read_byte_discriminator_buffer_too_short_is_access_error() {
-        let schema = byte_union_schema(4, "AlkType:Uint32");
+        let root = byte_union_root(4, "uint32");
+        let u = doc_union(&root, "U");
         let buf = [0u8; 2];
-        let err = read_byte_discriminator(&buf, &schema, LE).unwrap_err();
+        let err = read_byte_discriminator(&buf, &u, LE).unwrap_err();
         assert!(matches!(err, AlkTypeError::Access { .. }));
     }
 
     #[test]
     fn read_byte_discriminator_field_kind_is_schema_error() {
-        let schema = field_union_schema("type", "AlkType:String");
+        let root = field_union_root("type", "string");
+        let u = doc_union(&root, "U");
         let buf = [0u8; 16];
-        let err = read_byte_discriminator(&buf, &schema, LE).unwrap_err();
+        let err = read_byte_discriminator(&buf, &u, LE).unwrap_err();
         assert!(matches!(err, AlkTypeError::Schema(_)));
     }
 
     #[test]
     fn read_field_discriminator_string() {
-        let schema = field_union_schema("type", "AlkType:String");
+        let root = field_union_root("type", "string");
+        let u = doc_union(&root, "U");
         let mut buf = vec![0u8; 32];
         let value = "read";
         let len_bytes = (value.len() as u32).to_le_bytes();
         buf[0..4].copy_from_slice(&len_bytes);
         buf[4..4 + value.len()].copy_from_slice(value.as_bytes());
-        let d = read_field_discriminator(&buf, &schema, 0, LE).expect("read");
+        let d = read_field_discriminator(&buf, &u, 0, LE).expect("read");
         assert_eq!(d.key, "read");
         assert_eq!(d.variant_offset, 4 + value.len());
         assert_eq!(d.discriminator_size, 4 + value.len());
@@ -465,45 +411,37 @@ mod tests {
 
     #[test]
     fn read_field_discriminator_uint8() {
-        let schema = field_union_schema("type", "AlkType:Uint8");
+        let root = field_union_root("type", "uint8");
+        let u = doc_union(&root, "U");
         let mut buf = vec![0u8; 8];
         buf[0] = 0;
-        let d = read_field_discriminator(&buf, &schema, 0, LE).expect("read");
+        let d = read_field_discriminator(&buf, &u, 0, LE).expect("read");
         assert_eq!(d.key, "0");
         assert_eq!(d.variant_offset, 1);
         assert_eq!(d.discriminator_size, 1);
     }
 
-    #[test]
-    fn read_field_discriminator_enum() {
-        let schema = field_union_schema("type", "AlkType:Enum");
-        let mut buf = vec![0u8; 8];
-        buf[0..4].copy_from_slice(&0u32.to_le_bytes());
-        let d = read_field_discriminator(&buf, &schema, 0, LE).expect("read");
-        assert_eq!(d.key, "0");
-        assert_eq!(d.variant_offset, 4);
-        assert_eq!(d.discriminator_size, 4);
-    }
-
     #[test]
     fn read_field_discriminator_string_big_endian() {
-        let schema = field_union_schema("type", "AlkType:String");
+        let root = field_union_root("type", "string");
+        let u = doc_union(&root, "U");
         let mut buf = vec![0u8; 32];
         let value = "write";
         let len_bytes = (value.len() as u32).to_be_bytes();
         buf[0..4].copy_from_slice(&len_bytes);
         buf[4..4 + value.len()].copy_from_slice(value.as_bytes());
-        let d = read_field_discriminator(&buf, &schema, 0, BE).expect("read");
+        let d = read_field_discriminator(&buf, &u, 0, BE).expect("read");
         assert_eq!(d.key, "write");
         assert_eq!(d.variant_offset, 4 + value.len());
     }
 
     #[test]
     fn read_field_discriminator_unknown_value_is_access_error() {
-        let schema = field_union_schema("type", "AlkType:Uint8");
+        let root = field_union_root("type", "uint8");
+        let u = doc_union(&root, "U");
         let mut buf = vec![0u8; 8];
         buf[0] = 99;
-        let err = read_field_discriminator(&buf, &schema, 0, LE).unwrap_err();
+        let err = read_field_discriminator(&buf, &u, 0, LE).unwrap_err();
         match err {
             AlkTypeError::Access { field_path, reason } => {
                 assert_eq!(field_path, "type");
@@ -515,131 +453,91 @@ mod tests {
 
     #[test]
     fn read_field_discriminator_field_not_found_is_schema_error() {
-        let schema = json!({
-            "AlkType:Union": true,
-            "discriminator": {"kind": "field", "name": "missing"},
-            "properties": {"other": {"AlkType:Uint8": true}},
-            "mapping": {"5": {"AlkType:Struct": true}}
+        let root = json!({
+            "$defs": {
+                "U": {
+                    "kind": "union",
+                    "discriminator": { "kind": "field", "name": "missing" },
+                    "fields": [ { "name": "other", "kind": "uint8" } ],
+                    "mapping": { "5": { "kind": "struct", "fields": [] } }
+                }
+            }
         });
+        let u = doc_union(&root, "U");
         let buf = [0u8; 4];
-        let err = read_field_discriminator(&buf, &schema, 0, LE).unwrap_err();
-        assert!(matches!(err, AlkTypeError::Schema(_)));
-    }
-
-    #[test]
-    fn read_field_discriminator_no_alktype_kind_is_schema_error() {
-        let schema = json!({
-            "AlkType:Union": true,
-            "discriminator": {"kind": "field", "name": "type"},
-            "properties": {"type": {"type": "string"}},
-            "mapping": {"read": {"AlkType:Struct": true}}
-        });
-        let buf = [0u8; 4];
-        let err = read_field_discriminator(&buf, &schema, 0, LE).unwrap_err();
+        let err = read_field_discriminator(&buf, &u, 0, LE).unwrap_err();
         assert!(matches!(err, AlkTypeError::Schema(_)));
     }
 
     #[test]
     fn read_field_discriminator_unsupported_kind_is_schema_error() {
-        let schema = field_union_schema("type", "AlkType:Float32");
+        let root = json!({
+            "$defs": {
+                "U": {
+                    "kind": "union",
+                    "discriminator": { "kind": "field", "name": "type" },
+                    "fields": [ { "name": "type", "kind": "float32" } ],
+                    "mapping": { "read": { "kind": "struct", "fields": [] } }
+                }
+            }
+        });
+        let u = doc_union(&root, "U");
         let buf = [0u8; 8];
-        let err = read_field_discriminator(&buf, &schema, 0, LE).unwrap_err();
+        let err = read_field_discriminator(&buf, &u, 0, LE).unwrap_err();
         assert!(matches!(err, AlkTypeError::Schema(_)));
     }
 
     #[test]
     fn read_field_discriminator_byte_kind_is_schema_error() {
-        let schema = byte_union_schema(0, "AlkType:Uint8");
+        let root = byte_union_root(0, "uint8");
+        let u = doc_union(&root, "U");
         let buf = [5u8];
-        let err = read_field_discriminator(&buf, &schema, 0, LE).unwrap_err();
+        let err = read_field_discriminator(&buf, &u, 0, LE).unwrap_err();
         assert!(matches!(err, AlkTypeError::Schema(_)));
     }
 
     #[test]
-    fn resolve_variant_inline_schema() {
-        let schema = byte_union_schema(0, "AlkType:Uint8");
-        let variant = resolve_variant(&schema, "5").expect("resolve");
-        assert_eq!(
-            variant.get("AlkType:Struct").and_then(Value::as_bool),
-            Some(true)
-        );
-    }
-
-    #[test]
-    fn resolve_variant_ref_against_own_defs() {
-        let schema = json!({
-            "AlkType:Union": true,
-            "discriminator": {"kind": "byte"},
-            "mapping": {
-                "5": {"$ref": "#/$defs/Read"}
-            },
-            "$defs": {
-                "Read": {"AlkType:Struct": true, "properties": {"id": {"AlkType:Uint32": true}}}
-            }
-        });
-        let variant = resolve_variant(&schema, "5").expect("resolve");
-        assert_eq!(
-            variant.get("AlkType:Struct").and_then(Value::as_bool),
-            Some(true)
-        );
+    fn resolve_variant_returns_variant_type() {
+        let root = byte_union_root(0, "uint8");
+        let u = doc_union(&root, "U");
+        let variant = resolve_variant(&u, "5").expect("resolve");
+        assert!(matches!(variant, BastType::Struct(_)));
     }
 
     #[test]
     fn resolve_variant_unknown_key_is_schema_error() {
-        let schema = byte_union_schema(0, "AlkType:Uint8");
-        let err = resolve_variant(&schema, "999").unwrap_err();
-        assert!(matches!(err, AlkTypeError::Schema(_)));
-    }
-
-    #[test]
-    fn resolve_variant_missing_mapping_is_schema_error() {
-        let schema = json!({"AlkType:Union": true, "discriminator": {"kind": "byte"}});
-        let err = resolve_variant(&schema, "5").unwrap_err();
-        assert!(matches!(err, AlkTypeError::Schema(_)));
-    }
-
-    #[test]
-    fn resolve_variant_unresolvable_ref_is_schema_error() {
-        let schema = json!({
-            "AlkType:Union": true,
-            "discriminator": {"kind": "byte"},
-            "mapping": {
-                "5": {"$ref": "#/$defs/Read"}
-            }
-        });
-        let err = resolve_variant(&schema, "5").unwrap_err();
+        let root = byte_union_root(0, "uint8");
+        let u = doc_union(&root, "U");
+        let err = resolve_variant(&u, "999").unwrap_err();
         assert!(matches!(err, AlkTypeError::Schema(_)));
     }
 
     #[test]
     fn discriminator_size_uint8() {
-        let schema = byte_union_schema(0, "AlkType:Uint8");
-        assert_eq!(discriminator_size(&schema).unwrap(), 1);
+        let root = byte_union_root(0, "uint8");
+        let u = doc_union(&root, "U");
+        assert_eq!(discriminator_size(&u).unwrap(), 1);
     }
 
     #[test]
     fn discriminator_size_uint16() {
-        let schema = byte_union_schema(0, "AlkType:Uint16");
-        assert_eq!(discriminator_size(&schema).unwrap(), 2);
+        let root = byte_union_root(0, "uint16");
+        let u = doc_union(&root, "U");
+        assert_eq!(discriminator_size(&u).unwrap(), 2);
     }
 
     #[test]
     fn discriminator_size_uint32() {
-        let schema = byte_union_schema(0, "AlkType:Uint32");
-        assert_eq!(discriminator_size(&schema).unwrap(), 4);
+        let root = byte_union_root(0, "uint32");
+        let u = doc_union(&root, "U");
+        assert_eq!(discriminator_size(&u).unwrap(), 4);
     }
 
     #[test]
     fn discriminator_size_field_kind_is_schema_error() {
-        let schema = field_union_schema("type", "AlkType:String");
-        let err = discriminator_size(&schema).unwrap_err();
+        let root = field_union_root("type", "string");
+        let u = doc_union(&root, "U");
+        let err = discriminator_size(&u).unwrap_err();
         assert!(matches!(err, AlkTypeError::Schema(_)));
     }
-
-    #[test]
-    fn discriminator_size_missing_discriminator_is_schema_error() {
-        let schema = json!({"AlkType:Union": true});
-        let err = discriminator_size(&schema).unwrap_err();
-        assert!(matches!(err, AlkTypeError::Schema(_)));
-    }
-}
+}
\ No newline at end of file
diff --git a/tests/engine_integration.rs b/tests/engine_integration.rs
index b1b988a..0b0cb45 100644
--- a/tests/engine_integration.rs
+++ b/tests/engine_integration.rs
@@ -4,27 +4,34 @@
 //! accessors, validation convenience methods, and the aligned-mode
 //! `read_field` / `write_field` round-trip for the fixed-size primitive
 //! kinds and length-prefixed `String` / `Bytes`.
+//!
+//! All schemas are BAST documents (`{ "$defs": { ... } }` with `kind`-
+//! based vocabulary).
 
 use alktype::*;
 use serde_json::json;
 
-fn mixed_fixed_struct_schema() -> serde_json::Value {
+fn mixed_fixed_struct_doc() -> serde_json::Value {
     json!({
-        "AlkType:Struct": true,
-        "endian": "little",
-        "properties": {
-            "flag": { "AlkType:Uint8": true },
-            "id": { "AlkType:Uint32": true },
-            "score": { "AlkType:Float32": true },
-            "tag": { "AlkType:String": true }
+        "$defs": {
+            "S": {
+                "kind": "struct",
+                "endian": "little",
+                "fields": [
+                    { "name": "flag",  "kind": "uint8" },
+                    { "name": "id",    "kind": "uint32" },
+                    { "name": "score", "kind": "float32" },
+                    { "name": "tag",   "kind": "string" }
+                ]
+            }
         }
     })
 }
 
 #[test]
 fn compile_aligned_builds_engine_with_offset_map() -> Result<(), AlkTypeError> {
-    let mut schema = mixed_fixed_struct_schema();
-    let engine = AlkTypeEngine::compile(&mut schema, LayoutMode::Aligned)?;
+    let doc = mixed_fixed_struct_doc();
+    let engine = AlkTypeEngine::compile(&doc, "S", LayoutMode::Aligned)?;
     assert_eq!(engine.mode(), LayoutMode::Aligned);
     assert!(engine.offset_map().is_some());
     assert!(engine.layout_builder().is_none());
@@ -34,8 +41,8 @@ fn compile_aligned_builds_engine_with_offset_map() -> Result<(), AlkTypeError> {
 
 #[test]
 fn compile_packed_builds_engine_with_builder_and_reader() -> Result<(), AlkTypeError> {
-    let mut schema = mixed_fixed_struct_schema();
-    let engine = AlkTypeEngine::compile(&mut schema, LayoutMode::Packed)?;
+    let doc = mixed_fixed_struct_doc();
+    let engine = AlkTypeEngine::compile(&doc, "S", LayoutMode::Packed)?;
     assert_eq!(engine.mode(), LayoutMode::Packed);
     assert!(engine.offset_map().is_none());
     assert!(engine.layout_builder().is_some());
@@ -44,147 +51,96 @@ fn compile_packed_builds_engine_with_builder_and_reader() -> Result<(), AlkTypeE
 }
 
 #[test]
-fn compile_normalizes_bare_name_refs() -> Result<(), AlkTypeError> {
-    let mut schema = json!({
-        "AlkType:Struct": true,
-        "properties": {
-            "child": { "$ref": "Child" }
-        },
+fn compile_resolves_ref_fields() -> Result<(), AlkTypeError> {
+    let doc = json!({
         "$defs": {
+            "S": {
+                "kind": "struct",
+                "fields": [
+                    { "name": "child", "kind": { "$ref": "#/$defs/Child" } }
+                ]
+            },
             "Child": {
-                "AlkType:Struct": true,
-                "properties": { "x": { "AlkType:Uint8": true } }
+                "kind": "struct",
+                "fields": [ { "name": "x", "kind": "uint8" } ]
             }
         }
     });
-    let _engine = AlkTypeEngine::compile(&mut schema, LayoutMode::Packed)?;
-    assert_eq!(
-        schema["properties"]["child"]["$ref"],
-        json!("#/$defs/Child")
-    );
+    let _engine = AlkTypeEngine::compile(&doc, "S", LayoutMode::Packed)?;
     Ok(())
 }
 
 #[test]
-fn compile_leaves_full_pointer_refs_unchanged() -> Result<(), AlkTypeError> {
-    let mut schema = json!({
-        "AlkType:Struct": true,
-        "properties": {
-            "child": { "$ref": "#/$defs/Child" }
-        },
-        "$defs": {
-            "Child": {
-                "AlkType:Struct": true,
-                "properties": { "x": { "AlkType:Uint8": true } }
-            }
-        }
-    });
-    let _engine = AlkTypeEngine::compile(&mut schema, LayoutMode::Packed)?;
-    assert_eq!(
-        schema["properties"]["child"]["$ref"],
-        json!("#/$defs/Child")
-    );
-    Ok(())
+fn compile_returns_schema_error_when_no_defs() {
+    let doc = json!({ "type": "object", "properties": {} });
+    let err = AlkTypeEngine::compile(&doc, "S", LayoutMode::Aligned).unwrap_err();
+    assert!(matches!(err, AlkTypeError::Schema(_)), "got {err:?}");
 }
 
 #[test]
-fn compile_returns_schema_error_when_no_alktype_kind() {
-    let mut schema = json!({ "type": "object", "properties": {} });
-    let err = AlkTypeEngine::compile(&mut schema, LayoutMode::Aligned).unwrap_err();
+fn compile_returns_schema_error_for_missing_root() {
+    let doc = json!({ "$defs": { "Other": { "kind": "struct", "fields": [] } } });
+    let err = AlkTypeEngine::compile(&doc, "Missing", LayoutMode::Aligned).unwrap_err();
     assert!(matches!(err, AlkTypeError::Schema(_)), "got {err:?}");
 }
 
 #[test]
 fn endian_parsed_from_schema_big() -> Result<(), AlkTypeError> {
-    let mut schema = json!({
-        "AlkType:Struct": true,
-        "endian": "big",
-        "properties": { "id": { "AlkType:Uint32": true } }
+    let doc = json!({
+        "$defs": {
+            "S": {
+                "kind": "struct",
+                "endian": "big",
+                "fields": [ { "name": "id", "kind": "uint32" } ]
+            }
+        }
     });
-    let engine = AlkTypeEngine::compile(&mut schema, LayoutMode::Packed)?;
+    let engine = AlkTypeEngine::compile(&doc, "S", LayoutMode::Packed)?;
     assert_eq!(engine.endian(), Endian::Big);
     Ok(())
 }
 
 #[test]
 fn endian_defaults_to_little() -> Result<(), AlkTypeError> {
-    let mut schema = json!({
-        "AlkType:Struct": true,
-        "properties": { "id": { "AlkType:Uint32": true } }
+    let doc = json!({
+        "$defs": {
+            "S": {
+                "kind": "struct",
+                "fields": [ { "name": "id", "kind": "uint32" } ]
+            }
+        }
     });
-    let engine = AlkTypeEngine::compile(&mut schema, LayoutMode::Packed)?;
+    let engine = AlkTypeEngine::compile(&doc, "S", LayoutMode::Packed)?;
     assert_eq!(engine.endian(), Endian::Little);
     Ok(())
 }
 
-#[test]
-fn validate_json_accepts_valid_instance() -> Result<(), AlkTypeError> {
-    let mut schema = json!({
-        "AlkType:Struct": true,
-        "type": "object",
-        "properties": {
-            "id": { "AlkType:Uint32": true, "type": "integer" }
-        },
-        "required": ["id"]
-    });
-    let engine = AlkTypeEngine::compile(&mut schema, LayoutMode::Aligned)?;
-    assert!(engine.validate_json(&json!({"id": 42})).is_ok());
-    Ok(())
-}
-
-#[test]
-fn validate_json_rejects_invalid_instance() -> Result<(), AlkTypeError> {
-    let mut schema = json!({
-        "AlkType:Struct": true,
-        "type": "object",
-        "properties": {
-            "id": { "AlkType:Uint32": true, "type": "integer" }
-        },
-        "required": ["id"]
-    });
-    let engine = AlkTypeEngine::compile(&mut schema, LayoutMode::Aligned)?;
-    let err = engine.validate_json(&json!({"id": -1})).unwrap_err();
-    assert!(matches!(err, AlkTypeError::Validation(_)), "got {err:?}");
-    Ok(())
-}
-
-#[test]
-fn is_valid_json_returns_bool() -> Result<(), AlkTypeError> {
-    let mut schema = json!({
-        "AlkType:Struct": true,
-        "type": "object",
-        "properties": {
-            "id": { "AlkType:Uint32": true, "type": "integer" }
-        },
-        "required": ["id"]
-    });
-    let engine = AlkTypeEngine::compile(&mut schema, LayoutMode::Aligned)?;
-    assert!(engine.is_valid_json(&json!({"id": 42})));
-    assert!(!engine.is_valid_json(&json!({"id": -1})));
-    Ok(())
-}
-
 #[test]
 fn read_write_aligned_round_trips_all_fixed_size_kinds() -> Result<(), AlkTypeError> {
-    let mut schema = json!({
-        "AlkType:Struct": true,
-        "endian": "little",
-        "properties": {
-            "i8":  { "AlkType:Int8": true },
-            "u8":  { "AlkType:Uint8": true },
-            "i16": { "AlkType:Int16": true },
-            "u16": { "AlkType:Uint16": true },
-            "i32": { "AlkType:Int32": true },
-            "u32": { "AlkType:Uint32": true },
-            "i64": { "AlkType:Int64": true },
-            "u64": { "AlkType:Uint64": true },
-            "f32": { "AlkType:Float32": true },
-            "f64": { "AlkType:Float64": true },
-            "b":   { "AlkType:Boolean": true },
-            "e":   { "AlkType:Enum": true }
+    let doc = json!({
+        "$defs": {
+            "S": {
+                "kind": "struct",
+                "endian": "little",
+                "fields": [
+                    { "name": "i8",  "kind": "int8" },
+                    { "name": "u8",  "kind": "uint8" },
+                    { "name": "i16", "kind": "int16" },
+                    { "name": "u16", "kind": "uint16" },
+                    { "name": "i32", "kind": "int32" },
+                    { "name": "u32", "kind": "uint32" },
+                    { "name": "i64", "kind": "int64" },
+                    { "name": "u64", "kind": "uint64" },
+                    { "name": "f32", "kind": "float32" },
+                    { "name": "f64", "kind": "float64" },
+                    { "name": "b",   "kind": "bool" },
+                    { "name": "e",   "kind": { "$ref": "#/$defs/E" } }
+                ]
+            },
+            "E": { "kind": "enum", "values": ["A", "B", "C"] }
         }
     });
-    let engine = AlkTypeEngine::compile(&mut schema, LayoutMode::Aligned)?;
+    let engine = AlkTypeEngine::compile(&doc, "S", LayoutMode::Aligned)?;
     let offset_map = engine.offset_map().expect("aligned mode has offset_map");
     let mut buffer = vec![0u8; offset_map.total_size()];
 
@@ -230,13 +186,15 @@ fn read_write_aligned_round_trips_all_fixed_size_kinds() -> Result<(), AlkTypeEr
 
 #[test]
 fn read_write_aligned_round_trips_string() -> Result<(), AlkTypeError> {
-    let mut schema = json!({
-        "AlkType:Struct": true,
-        "properties": {
-            "name": { "AlkType:String": true }
+    let doc = json!({
+        "$defs": {
+            "S": {
+                "kind": "struct",
+                "fields": [ { "name": "name", "kind": "string" } ]
+            }
         }
     });
-    let engine = AlkTypeEngine::compile(&mut schema, LayoutMode::Aligned)?;
+    let engine = AlkTypeEngine::compile(&doc, "S", LayoutMode::Aligned)?;
     let offset_map = engine.offset_map().expect("aligned mode has offset_map");
     let mut buffer = vec![0u8; offset_map.total_size() + 64];
     engine.write_field(&mut buffer, "name", &FieldValue::String("hello world"))?;
@@ -249,13 +207,15 @@ fn read_write_aligned_round_trips_string() -> Result<(), AlkTypeError> {
 
 #[test]
 fn read_write_aligned_round_trips_bytes() -> Result<(), AlkTypeError> {
-    let mut schema = json!({
-        "AlkType:Struct": true,
-        "properties": {
-            "blob": { "AlkType:Bytes": true }
+    let doc = json!({
+        "$defs": {
+            "S": {
+                "kind": "struct",
+                "fields": [ { "name": "blob", "kind": "bytes" } ]
+            }
         }
     });
-    let engine = AlkTypeEngine::compile(&mut schema, LayoutMode::Aligned)?;
+    let engine = AlkTypeEngine::compile(&doc, "S", LayoutMode::Aligned)?;
     let offset_map = engine.offset_map().expect("aligned mode has offset_map");
     let payload = b"the quick brown fox".to_vec();
     let mut buffer = vec![0u8; offset_map.total_size() + payload.len()];
@@ -269,11 +229,15 @@ fn read_write_aligned_round_trips_bytes() -> Result<(), AlkTypeError> {
 
 #[test]
 fn read_field_returns_access_error_in_packed_mode() -> Result<(), AlkTypeError> {
-    let mut schema = json!({
-        "AlkType:Struct": true,
-        "properties": { "id": { "AlkType:Uint32": true } }
+    let doc = json!({
+        "$defs": {
+            "S": {
+                "kind": "struct",
+                "fields": [ { "name": "id", "kind": "uint32" } ]
+            }
+        }
     });
-    let engine = AlkTypeEngine::compile(&mut schema, LayoutMode::Packed)?;
+    let engine = AlkTypeEngine::compile(&doc, "S", LayoutMode::Packed)?;
     let buffer = [0u8; 4];
     let err = engine.read_field(&buffer, "id").unwrap_err();
     assert!(matches!(err, AlkTypeError::Access { .. }), "got {err:?}");
@@ -282,11 +246,15 @@ fn read_field_returns_access_error_in_packed_mode() -> Result<(), AlkTypeError>
 
 #[test]
 fn write_field_returns_access_error_in_packed_mode() -> Result<(), AlkTypeError> {
-    let mut schema = json!({
-        "AlkType:Struct": true,
-        "properties": { "id": { "AlkType:Uint32": true } }
+    let doc = json!({
+        "$defs": {
+            "S": {
+                "kind": "struct",
+                "fields": [ { "name": "id", "kind": "uint32" } ]
+            }
+        }
     });
-    let engine = AlkTypeEngine::compile(&mut schema, LayoutMode::Packed)?;
+    let engine = AlkTypeEngine::compile(&doc, "S", LayoutMode::Packed)?;
     let mut buffer = [0u8; 4];
     let err = engine
         .write_field(&mut buffer, "id", &FieldValue::U32(1))
@@ -297,11 +265,15 @@ fn write_field_returns_access_error_in_packed_mode() -> Result<(), AlkTypeError>
 
 #[test]
 fn read_field_returns_offset_error_for_missing_path() -> Result<(), AlkTypeError> {
-    let mut schema = json!({
-        "AlkType:Struct": true,
-        "properties": { "id": { "AlkType:Uint32": true } }
+    let doc = json!({
+        "$defs": {
+            "S": {
+                "kind": "struct",
+                "fields": [ { "name": "id", "kind": "uint32" } ]
+            }
+        }
     });
-    let engine = AlkTypeEngine::compile(&mut schema, LayoutMode::Aligned)?;
+    let engine = AlkTypeEngine::compile(&doc, "S", LayoutMode::Aligned)?;
     let buffer = [0u8; 8];
     let err = engine.read_field(&buffer, "missing").unwrap_err();
     assert!(matches!(err, AlkTypeError::Offset { .. }), "got {err:?}");
@@ -310,11 +282,15 @@ fn read_field_returns_offset_error_for_missing_path() -> Result<(), AlkTypeError
 
 #[test]
 fn write_field_returns_offset_error_for_missing_path() -> Result<(), AlkTypeError> {
-    let mut schema = json!({
-        "AlkType:Struct": true,
-        "properties": { "id": { "AlkType:Uint32": true } }
+    let doc = json!({
+        "$defs": {
+            "S": {
+                "kind": "struct",
+                "fields": [ { "name": "id", "kind": "uint32" } ]
+            }
+        }
     });
-    let engine = AlkTypeEngine::compile(&mut schema, LayoutMode::Aligned)?;
+    let engine = AlkTypeEngine::compile(&doc, "S", LayoutMode::Aligned)?;
     let mut buffer = [0u8; 8];
     let err = engine
         .write_field(&mut buffer, "missing", &FieldValue::U32(1))
@@ -324,30 +300,38 @@ fn write_field_returns_offset_error_for_missing_path() -> Result<(), AlkTypeErro
 }
 
 #[test]
-fn read_field_returns_access_error_for_composite_types() -> Result<(), AlkTypeError> {
-    let mut schema = json!({
-        "AlkType:Struct": true,
-        "properties": {
-            "vals": {
-                "AlkType:Array": true,
-                "items": { "AlkType:Uint32": true }
+fn read_field_returns_error_for_composite_types() -> Result<(), AlkTypeError> {
+    let doc = json!({
+        "$defs": {
+            "S": {
+                "kind": "struct",
+                "fields": [
+                    { "name": "vals", "kind": { "kind": "array", "element": "uint32", "count": 2 } }
+                ]
             }
         }
     });
-    let engine = AlkTypeEngine::compile(&mut schema, LayoutMode::Aligned)?;
+    let engine = AlkTypeEngine::compile(&doc, "S", LayoutMode::Aligned)?;
     let buffer = [0u8; 8];
     let err = engine.read_field(&buffer, "vals").unwrap_err();
-    assert!(matches!(err, AlkTypeError::Access { .. }), "got {err:?}");
+    assert!(
+        matches!(err, AlkTypeError::Access { .. } | AlkTypeError::Offset { .. }),
+        "got {err:?}"
+    );
     Ok(())
 }
 
 #[test]
 fn write_field_returns_access_error_for_composite_value() -> Result<(), AlkTypeError> {
-    let mut schema = json!({
-        "AlkType:Struct": true,
-        "properties": { "id": { "AlkType:Uint32": true } }
+    let doc = json!({
+        "$defs": {
+            "S": {
+                "kind": "struct",
+                "fields": [ { "name": "id", "kind": "uint32" } ]
+            }
+        }
     });
-    let engine = AlkTypeEngine::compile(&mut schema, LayoutMode::Aligned)?;
+    let engine = AlkTypeEngine::compile(&doc, "S", LayoutMode::Aligned)?;
     let mut buffer = [0u8; 8];
     let err = engine
         .write_field(&mut buffer, "id", &FieldValue::Struct { start: 0, end: 4 })
@@ -358,19 +342,26 @@ fn write_field_returns_access_error_for_composite_value() -> Result<(), AlkTypeE
 
 #[test]
 fn read_field_aligned_reads_nested_struct_byte_range() -> Result<(), AlkTypeError> {
-    let mut schema = json!({
-        "AlkType:Struct": true,
-        "properties": {
-            "header": {
-                "AlkType:Struct": true,
-                "properties": {
-                    "version": { "AlkType:Uint8": true },
-                    "magic": { "AlkType:Uint32": true }
-                }
+    let doc = json!({
+        "$defs": {
+            "S": {
+                "kind": "struct",
+                "fields": [
+                    {
+                        "name": "header",
+                        "kind": {
+                            "kind": "struct",
+                            "fields": [
+                                { "name": "version", "kind": "uint8" },
+                                { "name": "magic",   "kind": "uint32" }
+                            ]
+                        }
+                    }
+                ]
             }
         }
     });
-    let engine = AlkTypeEngine::compile(&mut schema, LayoutMode::Aligned)?;
+    let engine = AlkTypeEngine::compile(&doc, "S", LayoutMode::Aligned)?;
     let offset_map = engine.offset_map().expect("aligned mode");
     let mut buffer = vec![0u8; offset_map.total_size()];
 
@@ -386,4 +377,4 @@ fn read_field_aligned_reads_nested_struct_byte_range() -> Result<(), AlkTypeErro
         FieldValue::U32(0xCAFEBABE)
     );
     Ok(())
-}
+}
\ No newline at end of file
diff --git a/tests/error_paths.rs b/tests/error_paths.rs
index 5b65927..412872a 100644
--- a/tests/error_paths.rs
+++ b/tests/error_paths.rs
@@ -2,10 +2,13 @@
 //!
 //! Exercises the `AlkTypeError` variants across the crate:
 //! `Access` (buffer too short, invalid UTF-8, invalid boolean byte,
-//! unknown discriminator value), `Schema` (missing AlkType kind,
-//! malformed discriminator annotation), and `Offset` (missing
-//! variable-length field size in `LayoutBuilder::build`).
+//! unknown discriminator value), `Schema` (missing root, malformed
+//! discriminator annotation), and `Offset` (missing variable-length
+//! field size in `LayoutBuilder::build`).
+//!
+//! All schemas are BAST documents.
 
+use alktype::bast::BastDoc;
 use alktype::data_access;
 use alktype::tunion;
 use alktype::*;
@@ -149,128 +152,145 @@ fn write_string_buffer_too_short_returns_access_error() {
 }
 
 #[test]
-fn compile_missing_alktype_kind_returns_schema_error() {
-    let mut schema = json!({ "type": "object", "properties": {} });
-    let err = AlkTypeEngine::compile(&mut schema, LayoutMode::Aligned).unwrap_err();
+fn compile_missing_defs_returns_schema_error() {
+    let doc = json!({ "type": "object", "properties": {} });
+    let err = AlkTypeEngine::compile(&doc, "S", LayoutMode::Aligned).unwrap_err();
     assert!(matches!(err, AlkTypeError::Schema(_)), "got {err:?}");
 }
 
 #[test]
-fn offset_map_compute_missing_alktype_kind_returns_schema_error() {
-    let schema = json!({ "type": "object", "properties": {} });
-    let err = OffsetMap::compute(&schema).unwrap_err();
+fn compile_missing_root_returns_schema_error() {
+    let doc = json!({ "$defs": { "Other": { "kind": "struct", "fields": [] } } });
+    let err = AlkTypeEngine::compile(&doc, "Missing", LayoutMode::Aligned).unwrap_err();
     assert!(matches!(err, AlkTypeError::Schema(_)), "got {err:?}");
 }
 
 #[test]
 fn offset_map_compute_non_struct_top_level_returns_schema_error() {
-    let schema = json!({ "AlkType:Uint32": true });
-    let err = OffsetMap::compute(&schema).unwrap_err();
-    assert!(matches!(err, AlkTypeError::Schema(_)), "got {err:?}");
+    let root = json!({
+        "$defs": {
+            "U": {
+                "kind": "union",
+                "discriminator": { "kind": "byte", "offset": 0, "type": "uint8" },
+                "mapping": { "1": { "$ref": "#/$defs/A" } }
+            },
+            "A": { "kind": "struct", "fields": [] }
+        }
+    });
+    let doc = BastDoc::new(&root, "U").expect("doc");
+    let err = OffsetMap::compute(&doc).unwrap_err();
+    assert!(matches!(err, AlkTypeError::Schema(_)));
 }
 
 #[test]
-fn layout_builder_new_missing_alktype_kind_returns_schema_error() {
-    let schema = json!({ "type": "object", "properties": {} });
-    let err = LayoutBuilder::new(&schema).unwrap_err();
+fn layout_builder_new_missing_root_returns_schema_error() {
+    let root = json!({ "$defs": { "Other": { "kind": "struct", "fields": [] } } });
+    let err = LayoutBuilder::new(&root, "Missing").unwrap_err();
     assert!(matches!(err, AlkTypeError::Schema(_)), "got {err:?}");
 }
 
 #[test]
 fn layout_builder_new_non_struct_top_level_returns_schema_error() {
-    let schema = json!({ "AlkType:Uint32": true });
-    let err = LayoutBuilder::new(&schema).unwrap_err();
-    assert!(matches!(err, AlkTypeError::Schema(_)), "got {err:?}");
-}
-
-#[test]
-fn parse_discriminator_missing_returns_schema_error() {
-    let schema = json!({"AlkType:Union": true});
-    let err = parse_discriminator(&schema).unwrap_err();
-    assert!(matches!(err, AlkTypeError::Schema(_)), "got {err:?}");
-}
-
-#[test]
-fn parse_discriminator_field_missing_name_returns_schema_error() {
-    let schema = json!({
-        "AlkType:Union": true,
-        "discriminator": {"kind": "field"}
+    let root = json!({
+        "$defs": {
+            "U": {
+                "kind": "union",
+                "discriminator": { "kind": "byte", "offset": 0, "type": "uint8" },
+                "mapping": { "1": { "$ref": "#/$defs/A" } }
+            },
+            "A": { "kind": "struct", "fields": [] }
+        }
     });
-    let err = parse_discriminator(&schema).unwrap_err();
-    assert!(matches!(err, AlkTypeError::Schema(_)), "got {err:?}");
-}
-
-#[test]
-fn parse_discriminator_unknown_kind_returns_schema_error() {
-    let schema = json!({
-        "AlkType:Union": true,
-        "discriminator": {"kind": "magic"}
-    });
-    let err = parse_discriminator(&schema).unwrap_err();
-    assert!(matches!(err, AlkTypeError::Schema(_)), "got {err:?}");
-}
-
-#[test]
-fn parse_discriminator_byte_invalid_type_returns_schema_error() {
-    let schema = json!({
-        "AlkType:Union": true,
-        "discriminator": {"kind": "byte", "type": "AlkType:Float32"}
-    });
-    let err = parse_discriminator(&schema).unwrap_err();
+    let err = LayoutBuilder::new(&root, "U").unwrap_err();
     assert!(matches!(err, AlkTypeError::Schema(_)), "got {err:?}");
 }
 
 #[test]
 fn read_byte_discriminator_unknown_value_returns_access_error() -> Result<(), AlkTypeError> {
-    let union_schema = json!({
-        "AlkType:Union": true,
-        "discriminator": {"kind": "byte", "type": "AlkType:Uint8"},
-        "mapping": {"5": {"AlkType:Struct": true, "properties": {"x": {"AlkType:Uint8": true}}}}
+    let root = json!({
+        "$defs": {
+            "U": {
+                "kind": "union",
+                "discriminator": { "kind": "byte", "type": "uint8" },
+                "mapping": {
+                    "5": { "kind": "struct", "fields": [ { "name": "x", "kind": "uint8" } ] }
+                }
+            }
+        }
     });
+    let doc = BastDoc::new(&root, "U")?;
+    let union_def = match doc.root_def().kind() {
+        alktype::bast::BastDefKind::Union(u) => u,
+        _ => unreachable!(),
+    };
     let buffer = [99u8, 0x00, 0x00];
-    let err = tunion::read_byte_discriminator(&buffer, &union_schema, Endian::Little).unwrap_err();
+    let err = tunion::read_byte_discriminator(&buffer, union_def, Endian::Little).unwrap_err();
     assert!(matches!(err, AlkTypeError::Access { .. }), "got {err:?}");
     Ok(())
 }
 
 #[test]
 fn read_byte_discriminator_buffer_too_short_returns_access_error() -> Result<(), AlkTypeError> {
-    let union_schema = json!({
-        "AlkType:Union": true,
-        "discriminator": {"kind": "byte", "offset": 4, "type": "AlkType:Uint32"},
-        "mapping": {"5": {"AlkType:Struct": true, "properties": {"x": {"AlkType:Uint8": true}}}}
+    let root = json!({
+        "$defs": {
+            "U": {
+                "kind": "union",
+                "discriminator": { "kind": "byte", "offset": 4, "type": "uint32" },
+                "mapping": {
+                    "5": { "kind": "struct", "fields": [ { "name": "x", "kind": "uint8" } ] }
+                }
+            }
+        }
     });
+    let doc = BastDoc::new(&root, "U")?;
+    let union_def = match doc.root_def().kind() {
+        alktype::bast::BastDefKind::Union(u) => u,
+        _ => unreachable!(),
+    };
     let buffer = [0u8; 2];
-    let err = tunion::read_byte_discriminator(&buffer, &union_schema, Endian::Little).unwrap_err();
+    let err = tunion::read_byte_discriminator(&buffer, union_def, Endian::Little).unwrap_err();
     assert!(matches!(err, AlkTypeError::Access { .. }), "got {err:?}");
     Ok(())
 }
 
 #[test]
 fn read_field_discriminator_unknown_value_returns_access_error() -> Result<(), AlkTypeError> {
-    let union_schema = json!({
-        "AlkType:Union": true,
-        "discriminator": {"kind": "field", "name": "type"},
-        "properties": {"type": {"AlkType:Uint8": true}},
-        "mapping": {"0": {"AlkType:Struct": true, "properties": {"x": {"AlkType:Uint8": true}}}}
+    let root = json!({
+        "$defs": {
+            "U": {
+                "kind": "union",
+                "discriminator": { "kind": "field", "name": "type" },
+                "fields": [ { "name": "type", "kind": "uint8" } ],
+                "mapping": {
+                    "0": { "kind": "struct", "fields": [ { "name": "x", "kind": "uint8" } ] }
+                }
+            }
+        }
     });
+    let doc = BastDoc::new(&root, "U")?;
+    let union_def = match doc.root_def().kind() {
+        alktype::bast::BastDefKind::Union(u) => u,
+        _ => unreachable!(),
+    };
     let mut buffer = vec![0u8; 8];
     buffer[0] = 99;
     let err =
-        tunion::read_field_discriminator(&buffer, &union_schema, 0, Endian::Little).unwrap_err();
+        tunion::read_field_discriminator(&buffer, union_def, 0, Endian::Little).unwrap_err();
     assert!(matches!(err, AlkTypeError::Access { .. }), "got {err:?}");
     Ok(())
 }
 
 #[test]
 fn layout_builder_missing_var_size_returns_offset_error() {
-    let schema = json!({
-        "AlkType:Struct": true,
-        "properties": {
-            "name": { "AlkType:String": true }
+    let root = json!({
+        "$defs": {
+            "S": {
+                "kind": "struct",
+                "fields": [ { "name": "name", "kind": "string" } ]
+            }
         }
     });
-    let builder = LayoutBuilder::new(&schema).expect("builder");
+    let builder = LayoutBuilder::new(&root, "S").expect("builder");
     let empty: HashMap<String, usize> = HashMap::new();
     let err = builder.build(&empty).unwrap_err();
     match err {
@@ -285,39 +305,28 @@ fn layout_builder_missing_var_size_returns_offset_error() {
     }
 }
 
-#[test]
-fn layout_builder_missing_array_data_size_returns_offset_error() {
-    let schema = json!({
-        "AlkType:Struct": true,
-        "properties": {
-            "vals": {
-                "AlkType:Array": true,
-                "items": { "AlkType:Uint32": true }
-            }
-        }
-    });
-    let builder = LayoutBuilder::new(&schema).expect("builder");
-    let empty: HashMap<String, usize> = HashMap::new();
-    let err = builder.build(&empty).unwrap_err();
-    assert!(matches!(err, AlkTypeError::Offset { .. }), "got {err:?}");
-}
-
 #[test]
 fn layout_builder_missing_discriminator_value_returns_offset_error() {
-    let schema = json!({
-        "AlkType:Struct": true,
-        "properties": {
-            "payload": {
-                "AlkType:Union": true,
-                "discriminator": {"kind": "byte", "type": "AlkType:Uint8"},
-                "mapping": {"5": {"$ref": "#/$defs/Read"}}
-            }
-        },
+    let root = json!({
         "$defs": {
-            "Read": {"AlkType:Struct": true, "properties": {"x": {"AlkType:Uint8": true}}}
+            "S": {
+                "kind": "struct",
+                "fields": [
+                    { "name": "payload", "kind": { "$ref": "#/$defs/Packet" } }
+                ]
+            },
+            "Packet": {
+                "kind": "union",
+                "discriminator": { "kind": "byte", "type": "uint8" },
+                "mapping": { "5": { "$ref": "#/$defs/Read" } }
+            },
+            "Read": {
+                "kind": "struct",
+                "fields": [ { "name": "x", "kind": "uint8" } ]
+            }
         }
     });
-    let builder = LayoutBuilder::new(&schema).expect("builder");
+    let builder = LayoutBuilder::new(&root, "S").expect("builder");
     let empty: HashMap<String, usize> = HashMap::new();
     let err = builder.build(&empty).unwrap_err();
     assert!(matches!(err, AlkTypeError::Offset { .. }), "got {err:?}");
@@ -325,20 +334,26 @@ fn layout_builder_missing_discriminator_value_returns_offset_error() {
 
 #[test]
 fn layout_builder_unknown_discriminator_value_returns_offset_error() {
-    let schema = json!({
-        "AlkType:Struct": true,
-        "properties": {
-            "payload": {
-                "AlkType:Union": true,
-                "discriminator": {"kind": "byte", "type": "AlkType:Uint8"},
-                "mapping": {"5": {"$ref": "#/$defs/Read"}}
-            }
-        },
+    let root = json!({
         "$defs": {
-            "Read": {"AlkType:Struct": true, "properties": {"x": {"AlkType:Uint8": true}}}
+            "S": {
+                "kind": "struct",
+                "fields": [
+                    { "name": "payload", "kind": { "$ref": "#/$defs/Packet" } }
+                ]
+            },
+            "Packet": {
+                "kind": "union",
+                "discriminator": { "kind": "byte", "type": "uint8" },
+                "mapping": { "5": { "$ref": "#/$defs/Read" } }
+            },
+            "Read": {
+                "kind": "struct",
+                "fields": [ { "name": "x", "kind": "uint8" } ]
+            }
         }
     });
-    let builder = LayoutBuilder::new(&schema).expect("builder");
+    let builder = LayoutBuilder::new(&root, "S").expect("builder");
     let mut vs = HashMap::new();
     vs.insert("payload.__discriminator".to_string(), 99);
     let err = builder.build(&vs).unwrap_err();
@@ -352,34 +367,49 @@ fn layout_builder_unknown_discriminator_value_returns_offset_error() {
 
 #[test]
 fn sequential_reader_buffer_too_short_returns_access_error() {
-    let schema = json!({
-        "AlkType:Struct": true,
-        "properties": {
-            "id": { "AlkType:Uint32": true }
+    let root = json!({
+        "$defs": {
+            "S": {
+                "kind": "struct",
+                "fields": [ { "name": "id", "kind": "uint32" } ]
+            }
         }
     });
     let buffer = [0u8; 2];
-    let mut reader = SequentialReader::new(&schema).unwrap();
+    let mut reader = SequentialReader::new(&root, "S").unwrap();
     let err = reader.read_next(&buffer).unwrap_err();
     assert!(matches!(err, AlkTypeError::Access { .. }), "got {err:?}");
 }
 
 #[test]
 fn sequential_reader_unknown_field_returns_schema_error() {
-    let schema = json!({
-        "AlkType:Struct": true,
-        "properties": { "a": { "AlkType:Uint8": true } }
+    let root = json!({
+        "$defs": {
+            "S": {
+                "kind": "struct",
+                "fields": [ { "name": "a", "kind": "uint8" } ]
+            }
+        }
     });
     let buffer = [0u8; 4];
-    let mut reader = SequentialReader::new(&schema).unwrap();
+    let mut reader = SequentialReader::new(&root, "S").unwrap();
     let err = reader.read_field(&buffer, "missing").unwrap_err();
     assert!(matches!(err, AlkTypeError::Schema(_)), "got {err:?}");
 }
 
 #[test]
 fn sequential_reader_new_non_struct_returns_schema_error() {
-    let schema = json!({ "AlkType:Uint32": true });
-    let err = SequentialReader::new(&schema).unwrap_err();
+    let root = json!({
+        "$defs": {
+            "U": {
+                "kind": "union",
+                "discriminator": { "kind": "byte", "offset": 0, "type": "uint8" },
+                "mapping": { "1": { "$ref": "#/$defs/A" } }
+            },
+            "A": { "kind": "struct", "fields": [] }
+        }
+    });
+    let err = SequentialReader::new(&root, "U").unwrap_err();
     assert!(matches!(err, AlkTypeError::Schema(_)), "got {err:?}");
 }
 
@@ -412,4 +442,4 @@ fn read_string_indirect_invalid_utf8_returns_access_error() {
     let err = data_access::read_string_indirect(&index, 0, data_region, "name", Endian::Little)
         .unwrap_err();
     assert!(matches!(err, AlkTypeError::Access { .. }), "got {err:?}");
-}
+}
\ No newline at end of file
diff --git a/tests/poc_roundtrip.rs b/tests/poc_roundtrip.rs
index b6dce5d..e451c48 100644
--- a/tests/poc_roundtrip.rs
+++ b/tests/poc_roundtrip.rs
@@ -8,7 +8,12 @@
 //! walks. Each test writes values to a buffer at computed offsets and
 //! reads them back, asserting both the values and (where applicable)
 //! the byte positions.
+//!
+//! All schemas are BAST documents (`{ "$defs": { ... } }` with `kind`-
+//! based vocabulary). The root type name is passed to `OffsetMap::compute`
+//! / `LayoutBuilder::new` / `SequentialReader::new` / `AlkTypeEngine::compile`.
 
+use alktype::bast::BastDoc;
 use alktype::data_access;
 use alktype::tunion;
 use alktype::*;
@@ -21,16 +26,21 @@ fn var_sizes(pairs: &[(&str, usize)]) -> HashMap<String, usize> {
 
 #[test]
 fn fixed_size_round_trip_via_offset_map() -> Result<(), AlkTypeError> {
-    let schema = json!({
-        "AlkType:Struct": true,
-        "properties": {
-            "id": { "AlkType:Uint32": true },
-            "score": { "AlkType:Float32": true },
-            "flag": { "AlkType:Uint8": true },
-            "count": { "AlkType:Uint16": true }
+    let root = json!({
+        "$defs": {
+            "S": {
+                "kind": "struct",
+                "fields": [
+                    { "name": "id",    "kind": "uint32" },
+                    { "name": "score", "kind": "float32" },
+                    { "name": "flag",  "kind": "uint8" },
+                    { "name": "count", "kind": "uint16" }
+                ]
+            }
         }
     });
-    let offset_map = OffsetMap::compute(&schema)?;
+    let doc = BastDoc::new(&root, "S")?;
+    let offset_map = OffsetMap::compute(&doc)?;
     let mut buffer = vec![0u8; offset_map.total_size()];
 
     let id_range = offset_map.get("id").expect("id range");
@@ -64,16 +74,20 @@ fn fixed_size_round_trip_via_offset_map() -> Result<(), AlkTypeError> {
 
 #[test]
 fn fixed_size_round_trip_via_engine_aligned() -> Result<(), AlkTypeError> {
-    let mut schema = json!({
-        "AlkType:Struct": true,
-        "endian": "little",
-        "properties": {
-            "id": { "AlkType:Uint32": true },
-            "score": { "AlkType:Float32": true },
-            "flag": { "AlkType:Uint8": true }
+    let doc = json!({
+        "$defs": {
+            "S": {
+                "kind": "struct",
+                "endian": "little",
+                "fields": [
+                    { "name": "id",    "kind": "uint32" },
+                    { "name": "score", "kind": "float32" },
+                    { "name": "flag",  "kind": "uint8" }
+                ]
+            }
         }
     });
-    let engine = AlkTypeEngine::compile(&mut schema, LayoutMode::Aligned)?;
+    let engine = AlkTypeEngine::compile(&doc, "S", LayoutMode::Aligned)?;
     let offset_map = engine.offset_map().expect("aligned mode has offset_map");
     let mut buffer = vec![0u8; offset_map.total_size()];
 
@@ -107,13 +121,15 @@ fn string_round_trip_via_data_access() -> Result<(), AlkTypeError> {
 
 #[test]
 fn string_round_trip_via_engine_aligned() -> Result<(), AlkTypeError> {
-    let mut schema = json!({
-        "AlkType:Struct": true,
-        "properties": {
-            "name": { "AlkType:String": true }
+    let doc = json!({
+        "$defs": {
+            "S": {
+                "kind": "struct",
+                "fields": [ { "name": "name", "kind": "string" } ]
+            }
         }
     });
-    let engine = AlkTypeEngine::compile(&mut schema, LayoutMode::Aligned)?;
+    let engine = AlkTypeEngine::compile(&doc, "S", LayoutMode::Aligned)?;
     let offset_map = engine.offset_map().expect("aligned mode has offset_map");
     let mut buffer = vec![0u8; offset_map.total_size() + 64];
     engine.write_field(&mut buffer, "name", &FieldValue::String("hello"))?;
@@ -141,20 +157,28 @@ fn bytes_round_trip_via_data_access() -> Result<(), AlkTypeError> {
 
 #[test]
 fn nested_struct_round_trip_via_offset_map() -> Result<(), AlkTypeError> {
-    let schema = json!({
-        "AlkType:Struct": true,
-        "properties": {
-            "header": {
-                "AlkType:Struct": true,
-                "properties": {
-                    "version": { "AlkType:Uint32": true },
-                    "magic": { "AlkType:Uint32": true }
-                }
-            },
-            "payload": { "AlkType:Bytes": true }
+    let root = json!({
+        "$defs": {
+            "S": {
+                "kind": "struct",
+                "fields": [
+                    {
+                        "name": "header",
+                        "kind": {
+                            "kind": "struct",
+                            "fields": [
+                                { "name": "version", "kind": "uint32" },
+                                { "name": "magic",   "kind": "uint32" }
+                            ]
+                        }
+                    },
+                    { "name": "payload", "kind": "bytes" }
+                ]
+            }
         }
     });
-    let offset_map = OffsetMap::compute(&schema)?;
+    let doc = BastDoc::new(&root, "S")?;
+    let offset_map = OffsetMap::compute(&doc)?;
 
     let header_version = offset_map.get("header.version").expect("header.version");
     let header_magic = offset_map.get("header.magic").expect("header.magic");
@@ -210,20 +234,27 @@ fn nested_struct_round_trip_via_offset_map() -> Result<(), AlkTypeError> {
 
 #[test]
 fn nested_struct_round_trip_via_engine_aligned() -> Result<(), AlkTypeError> {
-    let mut schema = json!({
-        "AlkType:Struct": true,
-        "properties": {
-            "header": {
-                "AlkType:Struct": true,
-                "properties": {
-                    "version": { "AlkType:Uint8": true },
-                    "flags": { "AlkType:Uint8": true }
-                }
-            },
-            "payload_len": { "AlkType:Uint32": true }
+    let doc = json!({
+        "$defs": {
+            "S": {
+                "kind": "struct",
+                "fields": [
+                    {
+                        "name": "header",
+                        "kind": {
+                            "kind": "struct",
+                            "fields": [
+                                { "name": "version", "kind": "uint8" },
+                                { "name": "flags",   "kind": "uint8" }
+                            ]
+                        }
+                    },
+                    { "name": "payload_len", "kind": "uint32" }
+                ]
+            }
         }
     });
-    let engine = AlkTypeEngine::compile(&mut schema, LayoutMode::Aligned)?;
+    let engine = AlkTypeEngine::compile(&doc, "S", LayoutMode::Aligned)?;
     let offset_map = engine.offset_map().expect("aligned mode");
 
     assert_eq!(offset_map.get("header.version").unwrap().start, 0);
@@ -252,17 +283,21 @@ fn nested_struct_round_trip_via_engine_aligned() -> Result<(), AlkTypeError> {
 
 #[test]
 fn big_endian_round_trip_via_offset_map() -> Result<(), AlkTypeError> {
-    let schema = json!({
-        "AlkType:Struct": true,
-        "endian": "big",
-        "properties": {
-            "id": { "AlkType:Uint32": true },
-            "offset": { "AlkType:Float64": true }
+    let root = json!({
+        "$defs": {
+            "S": {
+                "kind": "struct",
+                "endian": "big",
+                "fields": [
+                    { "name": "id",     "kind": "uint32" },
+                    { "name": "offset", "kind": "float64" }
+                ]
+            }
         }
     });
-    let offset_map = OffsetMap::compute(&schema)?;
-    let endian = Endian::from_schema(&schema);
-    assert_eq!(endian, Endian::Big);
+    let doc = BastDoc::new(&root, "S")?;
+    let offset_map = OffsetMap::compute(&doc)?;
+    let endian = Endian::Big;
 
     let id_range = offset_map.get("id").expect("id");
     let offset_range = offset_map.get("offset").expect("offset");
@@ -290,14 +325,19 @@ fn big_endian_round_trip_via_offset_map() -> Result<(), AlkTypeError> {
 
 #[test]
 fn alignment_padding_round_trip_u8_then_u32() -> Result<(), AlkTypeError> {
-    let schema = json!({
-        "AlkType:Struct": true,
-        "properties": {
-            "flag": { "AlkType:Uint8": true },
-            "id": { "AlkType:Uint32": true }
+    let root = json!({
+        "$defs": {
+            "S": {
+                "kind": "struct",
+                "fields": [
+                    { "name": "flag", "kind": "uint8" },
+                    { "name": "id",   "kind": "uint32" }
+                ]
+            }
         }
     });
-    let offset_map = OffsetMap::compute(&schema)?;
+    let doc = BastDoc::new(&root, "S")?;
+    let offset_map = OffsetMap::compute(&doc)?;
 
     let flag_range = offset_map.get("flag").expect("flag");
     let id_range = offset_map.get("id").expect("id");
@@ -335,16 +375,20 @@ fn alignment_padding_round_trip_u8_then_u32() -> Result<(), AlkTypeError> {
 
 #[test]
 fn packed_layout_round_trip_via_layout_builder() -> Result<(), AlkTypeError> {
-    let schema = json!({
-        "AlkType:Struct": true,
-        "endian": "little",
-        "properties": {
-            "flag": { "AlkType:Uint8": true },
-            "id": { "AlkType:Uint32": true },
-            "payload": { "AlkType:String": true }
+    let root = json!({
+        "$defs": {
+            "S": {
+                "kind": "struct",
+                "endian": "little",
+                "fields": [
+                    { "name": "flag",    "kind": "uint8" },
+                    { "name": "id",      "kind": "uint32" },
+                    { "name": "payload", "kind": "string" }
+                ]
+            }
         }
     });
-    let builder = LayoutBuilder::new(&schema)?;
+    let builder = LayoutBuilder::new(&root, "S")?;
     let layout = builder.build(&var_sizes(&[("payload", 10)]))?;
 
     let flag_pos = layout.get("flag").expect("flag");
@@ -392,16 +436,20 @@ fn packed_layout_round_trip_via_layout_builder() -> Result<(), AlkTypeError> {
 
 #[test]
 fn sequential_reader_round_trip_packed_buffer() -> Result<(), AlkTypeError> {
-    let schema = json!({
-        "AlkType:Struct": true,
-        "endian": "little",
-        "properties": {
-            "id": { "AlkType:Uint8": true },
-            "name": { "AlkType:String": true },
-            "tail": { "AlkType:Uint8": true }
+    let root = json!({
+        "$defs": {
+            "S": {
+                "kind": "struct",
+                "endian": "little",
+                "fields": [
+                    { "name": "id",   "kind": "uint8" },
+                    { "name": "name", "kind": "string" },
+                    { "name": "tail", "kind": "uint8" }
+                ]
+            }
         }
     });
-    let builder = LayoutBuilder::new(&schema)?;
+    let builder = LayoutBuilder::new(&root, "S")?;
     let payload = "hello";
     let layout = builder.build(&var_sizes(&[("name", payload.len())]))?;
 
@@ -411,7 +459,7 @@ fn sequential_reader_round_trip_packed_buffer() -> Result<(), AlkTypeError> {
     let after = 1 + 4 + payload.len();
     data_access::write_u8(&mut buffer, after, 99, "tail")?;
 
-    let mut reader = SequentialReader::new(&schema)?;
+    let mut reader = SequentialReader::new(&root, "S")?;
     assert_eq!(reader.endian(), Endian::Little);
     assert_eq!(reader.position(), 0);
 
@@ -436,13 +484,17 @@ fn sequential_reader_round_trip_packed_buffer() -> Result<(), AlkTypeError> {
 
 #[test]
 fn sequential_reader_read_field_walks_preceding_fields() -> Result<(), AlkTypeError> {
-    let schema = json!({
-        "AlkType:Struct": true,
-        "endian": "little",
-        "properties": {
-            "a": { "AlkType:Uint8": true },
-            "b": { "AlkType:Uint32": true },
-            "c": { "AlkType:Uint8": true }
+    let root = json!({
+        "$defs": {
+            "S": {
+                "kind": "struct",
+                "endian": "little",
+                "fields": [
+                    { "name": "a", "kind": "uint8" },
+                    { "name": "b", "kind": "uint32" },
+                    { "name": "c", "kind": "uint8" }
+                ]
+            }
         }
     });
     let mut buffer = vec![0u8; 16];
@@ -450,7 +502,7 @@ fn sequential_reader_read_field_walks_preceding_fields() -> Result<(), AlkTypeEr
     data_access::write_u32(&mut buffer, 1, 0xDEADBEEF, "b", Endian::Little)?;
     data_access::write_u8(&mut buffer, 5, 9, "c")?;
 
-    let mut reader = SequentialReader::new(&schema)?;
+    let mut reader = SequentialReader::new(&root, "S")?;
     let value = reader.read_field(&buffer, "c")?;
     assert_eq!(value, FieldValue::U8(9));
     assert_eq!(reader.position(), 6);
@@ -463,74 +515,90 @@ fn sequential_reader_read_field_walks_preceding_fields() -> Result<(), AlkTypeEr
 
 #[test]
 fn tunion_byte_offset_discriminator_dispatch() -> Result<(), AlkTypeError> {
-    let union_schema = json!({
-        "AlkType:Union": true,
-        "discriminator": {
-            "kind": "byte",
-            "offset": 0,
-            "type": "AlkType:Uint8"
-        },
-        "mapping": {
-            "5": { "$ref": "#/$defs/Read" },
-            "6": { "$ref": "#/$defs/Write" }
-        },
+    let root = json!({
         "$defs": {
-            "Read": {
-                "AlkType:Struct": true,
-                "properties": {
-                    "handle": { "AlkType:Uint32": true },
-                    "length": { "AlkType:Uint32": true }
+            "Packet": {
+                "kind": "union",
+                "discriminator": { "kind": "byte", "offset": 0, "type": "uint8" },
+                "mapping": {
+                    "5": { "$ref": "#/$defs/Read" },
+                    "6": { "$ref": "#/$defs/Write" }
                 }
             },
+            "Read": {
+                "kind": "struct",
+                "fields": [
+                    { "name": "handle", "kind": "uint32" },
+                    { "name": "length", "kind": "uint32" }
+                ]
+            },
             "Write": {
-                "AlkType:Struct": true,
-                "properties": {
-                    "handle": { "AlkType:Uint32": true },
-                    "length": { "AlkType:Uint32": true },
-                    "data": { "AlkType:Uint32": true }
-                }
+                "kind": "struct",
+                "fields": [
+                    { "name": "handle", "kind": "uint32" },
+                    { "name": "length", "kind": "uint32" },
+                    { "name": "data",   "kind": "uint32" }
+                ]
             }
         }
     });
+    let doc = BastDoc::new(&root, "Packet")?;
+    let union_def = match doc.root_def().kind() {
+        alktype::bast::BastDefKind::Union(u) => u,
+        _ => unreachable!(),
+    };
     let mut buffer = vec![0u8; 32];
     buffer[0] = 5;
     data_access::write_u32(&mut buffer, 1, 0x01020304, "Read.handle", Endian::Big)?;
     data_access::write_u32(&mut buffer, 5, 4096, "Read.length", Endian::Big)?;
 
-    let dispatch = tunion::read_byte_discriminator(&buffer, &union_schema, Endian::Big)?;
+    let dispatch = tunion::read_byte_discriminator(&buffer, union_def, Endian::Big)?;
     assert_eq!(dispatch.key, "5");
     assert_eq!(dispatch.variant_offset, 1);
     assert_eq!(dispatch.discriminator_size, 1);
 
-    let variant = tunion::resolve_variant(&union_schema, &dispatch.key)?;
-    assert_eq!(
-        variant
-            .get("AlkType:Struct")
-            .and_then(serde_json::Value::as_bool),
-        Some(true)
-    );
+    let variant = tunion::resolve_variant(union_def, &dispatch.key)?;
+    match variant {
+        alktype::bast::BastType::Ref(r) => assert_eq!(r.name(), "Read"),
+        other => panic!("expected Ref to Read, got {other:?}"),
+    }
     Ok(())
 }
 
 #[test]
 fn tunion_byte_offset_discriminator_size_lookup() -> Result<(), AlkTypeError> {
-    let u8_schema = json!({
-        "AlkType:Union": true,
-        "discriminator": {"kind": "byte", "type": "AlkType:Uint8"},
-        "mapping": {}
-    });
-    let u16_schema = json!({
-        "AlkType:Union": true,
-        "discriminator": {"kind": "byte", "type": "AlkType:Uint16"},
-        "mapping": {}
-    });
-    let u32_schema = json!({
-        "AlkType:Union": true,
-        "discriminator": {"kind": "byte", "type": "AlkType:Uint32"},
-        "mapping": {}
-    });
-    assert_eq!(tunion::discriminator_size(&u8_schema)?, 1);
-    assert_eq!(tunion::discriminator_size(&u16_schema)?, 2);
-    assert_eq!(tunion::discriminator_size(&u32_schema)?, 4);
+    fn union_with(disc_type: &str) -> serde_json::Value {
+        json!({
+            "$defs": {
+                "U": {
+                    "kind": "union",
+                    "discriminator": { "kind": "byte", "type": disc_type },
+                    "mapping": { "1": { "$ref": "#/$defs/A" } }
+                },
+                "A": { "kind": "struct", "fields": [] }
+            }
+        })
+    }
+    let u8_root = union_with("uint8");
+    let u16_root = union_with("uint16");
+    let u32_root = union_with("uint32");
+    let u8_doc = BastDoc::new(&u8_root, "U")?;
+    let u16_doc = BastDoc::new(&u16_root, "U")?;
+    let u32_doc = BastDoc::new(&u32_root, "U")?;
+    let u8_union = match u8_doc.root_def().kind() {
+        alktype::bast::BastDefKind::Union(u) => u,
+        _ => unreachable!(),
+    };
+    let u16_union = match u16_doc.root_def().kind() {
+        alktype::bast::BastDefKind::Union(u) => u,
+        _ => unreachable!(),
+    };
+    let u32_union = match u32_doc.root_def().kind() {
+        alktype::bast::BastDefKind::Union(u) => u,
+        _ => unreachable!(),
+    };
+    assert_eq!(tunion::discriminator_size(u8_union)?, 1);
+    assert_eq!(tunion::discriminator_size(u16_union)?, 2);
+    assert_eq!(tunion::discriminator_size(u32_union)?, 4);
     Ok(())
-}
+}
\ No newline at end of file
diff --git a/tests/tunion_dispatch.rs b/tests/tunion_dispatch.rs
index cf65fe1..c8d5f03 100644
--- a/tests/tunion_dispatch.rs
+++ b/tests/tunion_dispatch.rs
@@ -6,103 +6,116 @@
 //! correct mapping key and variant offset, that `resolve_variant`
 //! follows `$ref` pointers, and that `discriminator_size` reports the
 //! right fixed sizes.
+//!
+//! All schemas are BAST documents.
 
+use alktype::bast::{BastDefKind, BastDoc, BastType, BastUnion};
 use alktype::data_access;
 use alktype::tunion;
 use alktype::{Endian, AlkTypeError};
 use serde_json::json;
 
-fn sftp_like_byte_union() -> serde_json::Value {
+fn sftp_like_byte_union_doc() -> serde_json::Value {
     json!({
-        "AlkType:Union": true,
-        "discriminator": {
-            "kind": "byte",
-            "offset": 0,
-            "type": "AlkType:Uint8"
-        },
-        "mapping": {
-            "5": { "$ref": "#/$defs/Read" },
-            "6": { "$ref": "#/$defs/Write" }
-        },
         "$defs": {
-            "Read": {
-                "AlkType:Struct": true,
-                "properties": {
-                    "handle": { "AlkType:Uint32": true },
-                    "length": { "AlkType:Uint32": true }
+            "Packet": {
+                "kind": "union",
+                "discriminator": {
+                    "kind": "byte",
+                    "offset": 0,
+                    "type": "uint8"
+                },
+                "mapping": {
+                    "5": { "$ref": "#/$defs/Read" },
+                    "6": { "$ref": "#/$defs/Write" }
                 }
             },
+            "Read": {
+                "kind": "struct",
+                "fields": [
+                    { "name": "handle", "kind": "uint32" },
+                    { "name": "length", "kind": "uint32" }
+                ]
+            },
             "Write": {
-                "AlkType:Struct": true,
-                "properties": {
-                    "handle": { "AlkType:Uint32": true },
-                    "length": { "AlkType:Uint32": true },
-                    "data": { "AlkType:Uint32": true }
-                }
+                "kind": "struct",
+                "fields": [
+                    { "name": "handle", "kind": "uint32" },
+                    { "name": "length", "kind": "uint32" },
+                    { "name": "data",   "kind": "uint32" }
+                ]
             }
         }
     })
 }
 
+fn union_of<'a>(root: &'a serde_json::Value, name: &'a str) -> BastUnion<'a> {
+    let doc = BastDoc::new(root, name).expect("bast doc");
+    match doc.root_def().kind() {
+        BastDefKind::Union(u) => u.clone(),
+        _ => panic!("root must be a union"),
+    }
+}
+
 #[test]
 fn read_byte_discriminator_uint8_dispatches_to_read() -> Result<(), AlkTypeError> {
-    let union_schema = sftp_like_byte_union();
+    let root = sftp_like_byte_union_doc();
+    let union_def = union_of(&root, "Packet");
     let mut buffer = vec![0u8; 16];
     buffer[0] = 5;
     data_access::write_u32(&mut buffer, 1, 0x01020304, "Read.handle", Endian::Big)?;
 
-    let dispatch = tunion::read_byte_discriminator(&buffer, &union_schema, Endian::Big)?;
+    let dispatch = tunion::read_byte_discriminator(&buffer, &union_def, Endian::Big)?;
     assert_eq!(dispatch.key, "5");
     assert_eq!(dispatch.variant_offset, 1);
     assert_eq!(dispatch.discriminator_size, 1);
 
-    let variant = tunion::resolve_variant(&union_schema, &dispatch.key)?;
-    assert_eq!(
-        variant
-            .get("AlkType:Struct")
-            .and_then(serde_json::Value::as_bool),
-        Some(true)
-    );
+    let variant = tunion::resolve_variant(&union_def, &dispatch.key)?;
+    match variant {
+        BastType::Ref(r) => assert_eq!(r.name(), "Read"),
+        other => panic!("expected Ref to Read, got {other:?}"),
+    }
     Ok(())
 }
 
 #[test]
 fn read_byte_discriminator_uint8_dispatches_to_write() -> Result<(), AlkTypeError> {
-    let union_schema = sftp_like_byte_union();
+    let root = sftp_like_byte_union_doc();
+    let union_def = union_of(&root, "Packet");
     let mut buffer = vec![0u8; 16];
     buffer[0] = 6;
     data_access::write_u32(&mut buffer, 1, 0xDEADBEEF, "Write.handle", Endian::Big)?;
 
-    let dispatch = tunion::read_byte_discriminator(&buffer, &union_schema, Endian::Big)?;
+    let dispatch = tunion::read_byte_discriminator(&buffer, &union_def, Endian::Big)?;
     assert_eq!(dispatch.key, "6");
     assert_eq!(dispatch.variant_offset, 1);
     assert_eq!(dispatch.discriminator_size, 1);
 
-    let variant = tunion::resolve_variant(&union_schema, &dispatch.key)?;
-    let props = variant
-        .get("properties")
-        .and_then(serde_json::Value::as_object)
-        .expect("variant has properties");
-    assert!(props.contains_key("data"));
+    let variant = tunion::resolve_variant(&union_def, &dispatch.key)?;
+    match variant {
+        BastType::Ref(r) => assert_eq!(r.name(), "Write"),
+        other => panic!("expected Ref to Write, got {other:?}"),
+    }
     Ok(())
 }
 
 #[test]
 fn read_byte_discriminator_uint16_little_endian() -> Result<(), AlkTypeError> {
-    let schema = json!({
-        "AlkType:Union": true,
-        "discriminator": {
-            "kind": "byte",
-            "offset": 2,
-            "type": "AlkType:Uint16"
-        },
-        "mapping": {
-            "5": {"AlkType:Struct": true, "properties": {"id": {"AlkType:Uint32": true}}}
+    let root = json!({
+        "$defs": {
+            "U": {
+                "kind": "union",
+                "discriminator": { "kind": "byte", "offset": 2, "type": "uint16" },
+                "mapping": {
+                    "5": { "kind": "struct", "fields": [ { "name": "id", "kind": "uint32" } ] }
+                }
+            }
         }
     });
+    let union_def = union_of(&root, "U");
     let mut buffer = vec![0u8; 16];
     buffer[2..4].copy_from_slice(&5u16.to_le_bytes());
-    let dispatch = tunion::read_byte_discriminator(&buffer, &schema, Endian::Little)?;
+    let dispatch = tunion::read_byte_discriminator(&buffer, &union_def, Endian::Little)?;
     assert_eq!(dispatch.key, "5");
     assert_eq!(dispatch.variant_offset, 4);
     assert_eq!(dispatch.discriminator_size, 2);
@@ -111,20 +124,21 @@ fn read_byte_discriminator_uint16_little_endian() -> Result<(), AlkTypeError> {
 
 #[test]
 fn read_byte_discriminator_uint32_big_endian() -> Result<(), AlkTypeError> {
-    let schema = json!({
-        "AlkType:Union": true,
-        "discriminator": {
-            "kind": "byte",
-            "offset": 0,
-            "type": "AlkType:Uint32"
-        },
-        "mapping": {
-            "101": {"AlkType:Struct": true, "properties": {"id": {"AlkType:Uint32": true}}}
+    let root = json!({
+        "$defs": {
+            "U": {
+                "kind": "union",
+                "discriminator": { "kind": "byte", "offset": 0, "type": "uint32" },
+                "mapping": {
+                    "101": { "kind": "struct", "fields": [ { "name": "id", "kind": "uint32" } ] }
+                }
+            }
         }
     });
+    let union_def = union_of(&root, "U");
     let mut buffer = vec![0u8; 16];
     buffer[0..4].copy_from_slice(&101u32.to_be_bytes());
-    let dispatch = tunion::read_byte_discriminator(&buffer, &schema, Endian::Big)?;
+    let dispatch = tunion::read_byte_discriminator(&buffer, &union_def, Endian::Big)?;
     assert_eq!(dispatch.key, "101");
     assert_eq!(dispatch.variant_offset, 4);
     assert_eq!(dispatch.discriminator_size, 4);
@@ -133,191 +147,198 @@ fn read_byte_discriminator_uint32_big_endian() -> Result<(), AlkTypeError> {
 
 #[test]
 fn read_byte_discriminator_unknown_value_returns_access_error() -> Result<(), AlkTypeError> {
-    let union_schema = sftp_like_byte_union();
+    let root = sftp_like_byte_union_doc();
+    let union_def = union_of(&root, "Packet");
     let buffer = [99u8, 0x00, 0x00, 0x00];
-    let err = tunion::read_byte_discriminator(&buffer, &union_schema, Endian::Big).unwrap_err();
+    let err = tunion::read_byte_discriminator(&buffer, &union_def, Endian::Big).unwrap_err();
     assert!(matches!(err, AlkTypeError::Access { .. }), "got {err:?}");
     Ok(())
 }
 
 #[test]
 fn read_field_discriminator_string_dispatches_to_read() -> Result<(), AlkTypeError> {
-    let union_schema = json!({
-        "AlkType:Union": true,
-        "discriminator": {"kind": "field", "name": "type"},
-        "properties": {
-            "type": { "AlkType:String": true }
-        },
-        "mapping": {
-            "read": {"$ref": "#/$defs/Read"},
-            "write": {"$ref": "#/$defs/Write"}
-        },
+    let root = json!({
         "$defs": {
-            "Read": {
-                "AlkType:Struct": true,
-                "properties": {
-                    "handle": { "AlkType:Uint32": true },
-                    "length": { "AlkType:Uint32": true }
+            "Event": {
+                "kind": "union",
+                "discriminator": { "kind": "field", "name": "type" },
+                "fields": [ { "name": "type", "kind": "string" } ],
+                "mapping": {
+                    "read":  { "$ref": "#/$defs/Read" },
+                    "write": { "$ref": "#/$defs/Write" }
                 }
             },
+            "Read": {
+                "kind": "struct",
+                "fields": [
+                    { "name": "handle", "kind": "uint32" },
+                    { "name": "length", "kind": "uint32" }
+                ]
+            },
             "Write": {
-                "AlkType:Struct": true,
-                "properties": {
-                    "handle": { "AlkType:Uint32": true },
-                    "data": { "AlkType:Bytes": true }
-                }
+                "kind": "struct",
+                "fields": [
+                    { "name": "handle", "kind": "uint32" },
+                    { "name": "data",   "kind": "bytes" }
+                ]
             }
         }
     });
+    let union_def = union_of(&root, "Event");
     let value = "read";
     let mut buffer = vec![0u8; 32];
     data_access::write_string(&mut buffer, 0, value, "type", Endian::Little)?;
-    let dispatch = tunion::read_field_discriminator(&buffer, &union_schema, 0, Endian::Little)?;
+    let dispatch = tunion::read_field_discriminator(&buffer, &union_def, 0, Endian::Little)?;
     assert_eq!(dispatch.key, "read");
     assert_eq!(dispatch.variant_offset, 4 + value.len());
     assert_eq!(dispatch.discriminator_size, 4 + value.len());
 
-    let variant = tunion::resolve_variant(&union_schema, &dispatch.key)?;
-    assert_eq!(
-        variant
-            .get("AlkType:Struct")
-            .and_then(serde_json::Value::as_bool),
-        Some(true)
-    );
+    let variant = tunion::resolve_variant(&union_def, &dispatch.key)?;
+    match variant {
+        BastType::Ref(r) => assert_eq!(r.name(), "Read"),
+        other => panic!("expected Ref to Read, got {other:?}"),
+    }
     Ok(())
 }
 
 #[test]
 fn read_field_discriminator_string_dispatches_to_write() -> Result<(), AlkTypeError> {
-    let union_schema = json!({
-        "AlkType:Union": true,
-        "discriminator": {"kind": "field", "name": "type"},
-        "properties": {
-            "type": { "AlkType:String": true }
-        },
-        "mapping": {
-            "read": {"$ref": "#/$defs/Read"},
-            "write": {"$ref": "#/$defs/Write"}
-        },
+    let root = json!({
         "$defs": {
+            "Event": {
+                "kind": "union",
+                "discriminator": { "kind": "field", "name": "type" },
+                "fields": [ { "name": "type", "kind": "string" } ],
+                "mapping": {
+                    "read":  { "$ref": "#/$defs/Read" },
+                    "write": { "$ref": "#/$defs/Write" }
+                }
+            },
             "Read": {
-                "AlkType:Struct": true,
-                "properties": {"x": {"AlkType:Uint8": true}}
+                "kind": "struct",
+                "fields": [ { "name": "x", "kind": "uint8" } ]
             },
             "Write": {
-                "AlkType:Struct": true,
-                "properties": {"y": {"AlkType:Uint16": true}}
+                "kind": "struct",
+                "fields": [ { "name": "y", "kind": "uint16" } ]
             }
         }
     });
+    let union_def = union_of(&root, "Event");
     let value = "write";
     let mut buffer = vec![0u8; 32];
     data_access::write_string(&mut buffer, 0, value, "type", Endian::Little)?;
-    let dispatch = tunion::read_field_discriminator(&buffer, &union_schema, 0, Endian::Little)?;
+    let dispatch = tunion::read_field_discriminator(&buffer, &union_def, 0, Endian::Little)?;
     assert_eq!(dispatch.key, "write");
     assert_eq!(dispatch.variant_offset, 4 + value.len());
 
-    let variant = tunion::resolve_variant(&union_schema, &dispatch.key)?;
-    let props = variant
-        .get("properties")
-        .and_then(serde_json::Value::as_object)
-        .expect("variant has properties");
-    assert!(props.contains_key("y"));
-    assert!(!props.contains_key("x"));
+    let variant = tunion::resolve_variant(&union_def, &dispatch.key)?;
+    match variant {
+        BastType::Ref(r) => assert_eq!(r.name(), "Write"),
+        other => panic!("expected Ref to Write, got {other:?}"),
+    }
     Ok(())
 }
 
 #[test]
 fn read_field_discriminator_uint8_field() -> Result<(), AlkTypeError> {
-    let union_schema = json!({
-        "AlkType:Union": true,
-        "discriminator": {"kind": "field", "name": "tag"},
-        "properties": {
-            "tag": { "AlkType:Uint8": true }
-        },
-        "mapping": {
-            "0": {"AlkType:Struct": true, "properties": {"a": {"AlkType:Uint32": true}}},
-            "1": {"AlkType:Struct": true, "properties": {"b": {"AlkType:Uint16": true}}}
+    let root = json!({
+        "$defs": {
+            "Event": {
+                "kind": "union",
+                "discriminator": { "kind": "field", "name": "tag" },
+                "fields": [ { "name": "tag", "kind": "uint8" } ],
+                "mapping": {
+                    "0": { "kind": "struct", "fields": [ { "name": "a", "kind": "uint32" } ] },
+                    "1": { "kind": "struct", "fields": [ { "name": "b", "kind": "uint16" } ] }
+                }
+            }
         }
     });
+    let union_def = union_of(&root, "Event");
     let mut buffer = vec![0u8; 8];
     buffer[0] = 0;
-    let dispatch = tunion::read_field_discriminator(&buffer, &union_schema, 0, Endian::Little)?;
+    let dispatch = tunion::read_field_discriminator(&buffer, &union_def, 0, Endian::Little)?;
     assert_eq!(dispatch.key, "0");
     assert_eq!(dispatch.variant_offset, 1);
     assert_eq!(dispatch.discriminator_size, 1);
 
     buffer[0] = 1;
-    let dispatch = tunion::read_field_discriminator(&buffer, &union_schema, 0, Endian::Little)?;
+    let dispatch = tunion::read_field_discriminator(&buffer, &union_def, 0, Endian::Little)?;
     assert_eq!(dispatch.key, "1");
     Ok(())
 }
 
 #[test]
 fn read_field_discriminator_unknown_value_returns_access_error() -> Result<(), AlkTypeError> {
-    let union_schema = json!({
-        "AlkType:Union": true,
-        "discriminator": {"kind": "field", "name": "tag"},
-        "properties": {
-            "tag": { "AlkType:Uint8": true }
-        },
-        "mapping": {
-            "0": {"AlkType:Struct": true, "properties": {"a": {"AlkType:Uint32": true}}}
+    let root = json!({
+        "$defs": {
+            "Event": {
+                "kind": "union",
+                "discriminator": { "kind": "field", "name": "tag" },
+                "fields": [ { "name": "tag", "kind": "uint8" } ],
+                "mapping": {
+                    "0": { "kind": "struct", "fields": [ { "name": "a", "kind": "uint32" } ] }
+                }
+            }
         }
     });
+    let union_def = union_of(&root, "Event");
     let mut buffer = vec![0u8; 8];
     buffer[0] = 99;
     let err =
-        tunion::read_field_discriminator(&buffer, &union_schema, 0, Endian::Little).unwrap_err();
+        tunion::read_field_discriminator(&buffer, &union_def, 0, Endian::Little).unwrap_err();
     assert!(matches!(err, AlkTypeError::Access { .. }), "got {err:?}");
     Ok(())
 }
 
 #[test]
 fn discriminator_size_returns_correct_values() -> Result<(), AlkTypeError> {
-    let u8_schema = json!({
-        "AlkType:Union": true,
-        "discriminator": {"kind": "byte", "type": "AlkType:Uint8"},
-        "mapping": {}
-    });
-    let u16_schema = json!({
-        "AlkType:Union": true,
-        "discriminator": {"kind": "byte", "type": "AlkType:Uint16"},
-        "mapping": {}
-    });
-    let u32_schema = json!({
-        "AlkType:Union": true,
-        "discriminator": {"kind": "byte", "type": "AlkType:Uint32"},
-        "mapping": {}
-    });
-    assert_eq!(tunion::discriminator_size(&u8_schema)?, 1);
-    assert_eq!(tunion::discriminator_size(&u16_schema)?, 2);
-    assert_eq!(tunion::discriminator_size(&u32_schema)?, 4);
+    fn union_with(disc_type: &str) -> serde_json::Value {
+        json!({
+            "$defs": {
+                "U": {
+                    "kind": "union",
+                    "discriminator": { "kind": "byte", "type": disc_type },
+                    "mapping": { "1": { "$ref": "#/$defs/A" } }
+                },
+                "A": { "kind": "struct", "fields": [] }
+            }
+        })
+    }
+    let u8_root = union_with("uint8");
+    let u16_root = union_with("uint16");
+    let u32_root = union_with("uint32");
+    let u8_union = union_of(&u8_root, "U");
+    let u16_union = union_of(&u16_root, "U");
+    let u32_union = union_of(&u32_root, "U");
+    assert_eq!(tunion::discriminator_size(&u8_union)?, 1);
+    assert_eq!(tunion::discriminator_size(&u16_union)?, 2);
+    assert_eq!(tunion::discriminator_size(&u32_union)?, 4);
     Ok(())
 }
 
 #[test]
 fn discriminator_size_field_kind_returns_schema_error() {
-    let schema = json!({
-        "AlkType:Union": true,
-        "discriminator": {"kind": "field", "name": "type"},
-        "properties": {"type": {"AlkType:Uint8": true}},
-        "mapping": {}
+    let root = json!({
+        "$defs": {
+            "U": {
+                "kind": "union",
+                "discriminator": { "kind": "field", "name": "type" },
+                "fields": [ { "name": "type", "kind": "uint8" } ],
+                "mapping": { "0": { "kind": "struct", "fields": [] } }
+            }
+        }
     });
-    let err = tunion::discriminator_size(&schema).unwrap_err();
+    let union_def = union_of(&root, "U");
+    let err = tunion::discriminator_size(&union_def).unwrap_err();
     assert!(matches!(err, AlkTypeError::Schema(_)), "got {err:?}");
 }
 
 #[test]
 fn resolve_variant_returns_schema_error_for_unknown_key() {
-    let union_schema = sftp_like_byte_union();
-    let err = tunion::resolve_variant(&union_schema, "999").unwrap_err();
+    let root = sftp_like_byte_union_doc();
+    let union_def = union_of(&root, "Packet");
+    let err = tunion::resolve_variant(&union_def, "999").unwrap_err();
     assert!(matches!(err, AlkTypeError::Schema(_)), "got {err:?}");
-}
-
-#[test]
-fn parse_discriminator_missing_returns_schema_error() {
-    let schema = json!({"AlkType:Union": true});
-    let err = alktype::parse_discriminator(&schema).unwrap_err();
-    assert!(matches!(err, AlkTypeError::Schema(_)), "got {err:?}");
-}
+}
\ No newline at end of file