diff --git a/.aspect/config.axl b/.aspect/config.axl
index 89fbd405d..486ea5f65 100644
--- a/.aspect/config.axl
+++ b/.aspect/config.axl
@@ -10,8 +10,7 @@ task2 = task(
 
 def config(ctx: ConfigContext):
     ctx.tasks.add(task2, name = "added_by_config", group = [])
-    print("running config")
-    for task in ctx.tasks:
-        print(task.name, task.group)
+    # for task in ctx.tasks:
+    #     print(task.name, task.group, task.binding)
 
     pass
diff --git a/.aspect/delivery.axl b/.aspect/delivery.axl
new file mode 100644
index 000000000..ed3ec13f1
--- /dev/null
+++ b/.aspect/delivery.axl
@@ -0,0 +1,329 @@
+"""
+Delivery task that coordinates artifact delivery via Redis.
+
+Reads the delivery manifest for a commit, delivers each target via bazel run
+with stamping enabled, and signs artifacts to prevent re-delivery.
+
+See: DELIVERY_REDIS_KEYS.md for key format documentation.
+"""
+
+# Redis command helpers
+
+def _redis_cmd(ctx, redis_cfg, *cmd_args):
+    """Execute a redis-cli command and return the output."""
+    host, port, use_tls = redis_cfg
+
+    cmd = ctx.std.process.command("redis-cli")
+    cmd.args(["-h", host, "-p", str(port)])
+    # Add connection timeout to prevent hanging on TLS mismatch
+    cmd.args(["-t", "5"])
+    if use_tls:
+        cmd.arg("--tls")
+    cmd.args(list(cmd_args))
+    cmd.stdout("piped")
+    cmd.stderr("piped")
+
+    child = cmd.spawn()
+    output = child.wait_with_output()
+
+    if not output.status.success:
+        fail("redis-cli failed: " + output.stderr)
+
+    return output.stdout.strip()
+
+def _redis_get(ctx, redis_cfg, key):
+    """GET a value by key from Redis."""
+    result = _redis_cmd(ctx, redis_cfg, "GET", key)
+    return None if result == "(nil)" else result
+
+def _redis_set(ctx, redis_cfg, key, value):
+    """SET a key-value pair in Redis."""
+    return _redis_cmd(ctx, redis_cfg, "SET", key, value)
+
+def _redis_setnx(ctx, redis_cfg, key, value):
+    """SETNX - set if not exists. Returns True if key was set, False if it already existed."""
+    result = _redis_cmd(ctx, redis_cfg, "SETNX", key, value)
+    return result == "1"
+
+def _redis_del(ctx, redis_cfg, key):
+    """DEL a key from Redis."""
+    return _redis_cmd(ctx, redis_cfg, "DEL", key)
+
+def _redis_lrange(ctx, redis_cfg, key, start, stop):
+    """LRANGE to get list elements from Redis."""
+    result = _redis_cmd(ctx, redis_cfg, "LRANGE", key, str(start), str(stop))
+    if not result or result == "(empty list or set)":
+        return []
+    # Parse redis-cli output format (numbered lines)
+    lines = result.split("\n")
+    items = []
+    for line in lines:
+        # Format: "1) value" or just "value"
+        if ") " in line:
+            items.append(line.split(") ", 1)[1])
+        elif line:
+            items.append(line)
+    return items
+
+# Key builders (match format from delivery-base.task.ts)
+
+def _artifact_metadata_key(ci_host, output_sha, workspace):
+    """
+    Redis key for mapping of output sha -> metadata.
+    Format: <ciHost>:<outputSha>:<workspace>
+    """
+    return "{}:{}:{}".format(ci_host, output_sha, workspace)
+
+def _delivery_manifest_key(ci_host, commit_sha, workspace):
+    """
+    Redis key for mapping of commit sha -> delivery target list.
+    Format: <ciHost>:<commitSha>:<workspace>
+    """
+    return "{}:{}:{}".format(ci_host, commit_sha, workspace)
+
+def _output_sha_lookup_key(ci_host, commit_sha, workspace, label):
+    """
+    Redis key for reverse mapping of label -> output sha for a commit.
+    Format: output-sha:<ciHost>:<commitSha>:<workspace>:<label>
+    """
+    return "output-sha:{}:{}:{}:{}".format(ci_host, commit_sha, workspace, label)
+
+def _delivery_signature_key(ci_host, output_sha, workspace):
+    """
+    Redis key for atomically signing an artifact after delivery.
+    Format: delivery-signature:<ciHost>:<outputSha>:<workspace>
+    """
+    return "delivery-signature:{}:{}:{}".format(ci_host, output_sha, workspace)
+
+# Delivery implementation
+
+def _get_override_targets(ctx):
+    """
+    Check for override targets from environment variables.
+    ASPECT_WORKFLOWS_DELIVERY_TARGETS or DELIVERY_TARGETS (legacy).
+    Returns a set of target labels, or empty set if none.
+    """
+    targets_str = ctx.std.env.var("ASPECT_WORKFLOWS_DELIVERY_TARGETS")
+    if not targets_str:
+        targets_str = ctx.std.env.var("DELIVERY_TARGETS")
+    if not targets_str:
+        return set()
+
+    # Split on whitespace and filter valid labels
+    targets = []
+    for t in targets_str.split():
+        t = t.strip()
+        if t.startswith("//") or t.startswith("@"):
+            targets.append(t)
+    return set(targets)
+
+def _get_commit_sha(ctx, args_commit_sha):
+    """
+    Get commit SHA from env vars or args.
+    Priority: ASPECT_WORKFLOWS_DELIVERY_COMMIT > DELIVERY_COMMIT > args.
+    """
+    commit = ctx.std.env.var("ASPECT_WORKFLOWS_DELIVERY_COMMIT")
+    if commit:
+        return commit
+    commit = ctx.std.env.var("DELIVERY_COMMIT")
+    if commit:
+        return commit
+    return args_commit_sha
+
+def _run_bazel(ctx, verb, target, flags):
+    """
+    Run a bazel command and return the exit code.
+    TODO: Implement ctx.bazel.run() when available.
+    """
+    print("    [TODO] bazel {} {} {}".format(verb, " ".join(flags), target))
+    return 0  # Simulate success
+
+def _deliver_target(ctx, redis_cfg, ci_host, commit_sha, workspace, build_url, bazel_flags, label, is_forced):
+    """
+    Deliver a single target.
+
+    Args:
+        is_forced: If True, skip signature check and always deliver.
+
+    Returns (status: str, message: str) where status is one of:
+        - "success": Successfully delivered
+        - "skipped": Already delivered (only for non-forced)
+        - "build_failed": Bazel build failed
+        - "run_failed": Bazel run failed
+    """
+    output_sha = None
+    delivery_signature_key = None
+
+    # For non-forced targets, check if already delivered
+    if not is_forced:
+        # Look up output SHA for this target
+        lookup_key = _output_sha_lookup_key(ci_host, commit_sha, workspace, label)
+        output_sha = _redis_get(ctx, redis_cfg, lookup_key)
+
+        if output_sha:
+            delivery_signature_key = _delivery_signature_key(ci_host, output_sha, workspace)
+            existing_sig = _redis_get(ctx, redis_cfg, delivery_signature_key)
+
+            if existing_sig:
+                return ("skipped", "Already delivered by {}".format(existing_sig))
+        else:
+            # No output SHA found - target may have been added before signatures
+            # were introduced. Proceed with delivery.
+            print("  Warning: No output SHA found for {}, bypassing signature check".format(label))
+
+    # Run bazel to deliver the target with stamping
+    print("  Delivering {}...".format(label))
+    exit_code = _run_bazel(ctx, "run", label, bazel_flags)
+
+    if exit_code != 0:
+        # Delivery failed - delete artifact metadata so it can be retried
+        # (only for non-forced targets with known output SHA)
+        if output_sha and not is_forced:
+            artifact_key = _artifact_metadata_key(ci_host, output_sha, workspace)
+            _redis_del(ctx, redis_cfg, artifact_key)
+        return ("run_failed", "Delivery failed with exit code {}".format(exit_code))
+
+    # Sign the artifact to mark as delivered (only for non-forced with signature key)
+    if delivery_signature_key:
+        _redis_set(ctx, redis_cfg, delivery_signature_key, build_url)
+
+    return ("success", "Delivered successfully")
+
+def _delivery_impl(ctx):
+    # Redis configuration
+    host = ctx.args.host
+    port = ctx.args.port
+    use_tls = ctx.args.tls
+    redis_cfg = (host, port, use_tls)
+
+    # Delivery context
+    ci_host = ctx.args.ci_host
+    workspace = ctx.args.workspace
+    build_url = ctx.args.build_url
+
+    # Get commit SHA (env vars take precedence)
+    commit_sha = _get_commit_sha(ctx, ctx.args.commit_sha)
+    if not commit_sha:
+        fail("commit_sha is required (via --commit_sha or ASPECT_WORKFLOWS_DELIVERY_COMMIT env var)")
+
+    # Build bazel flags for delivery
+    # Default: --stamp --noremote_upload_local_results --remote_download_outputs=toplevel
+    stamp_flags_str = ctx.args.stamp_flags
+    if stamp_flags_str:
+        bazel_flags = stamp_flags_str.split(",")
+    else:
+        bazel_flags = ["--stamp"]
+
+    # Add flags that Workflows forces during delivery
+    bazel_flags.append("--noremote_upload_local_results")
+    bazel_flags.append("--remote_download_outputs=toplevel")
+
+    print("Delivery task starting")
+    print("  Redis: {}:{} (TLS: {})".format(host, port, use_tls))
+    print("  CI: {} commit: {} workspace: {}".format(ci_host, commit_sha, workspace))
+    print("  Build URL: {}".format(build_url))
+    print("  Bazel flags: {}".format(bazel_flags))
+
+    # Check for override targets (manual delivery / break the glass)
+    override_targets = _get_override_targets(ctx)
+    forced_targets = set()
+
+    if override_targets:
+        print("")
+        print("Found {} override target(s) from ASPECT_WORKFLOWS_DELIVERY_TARGETS".format(len(override_targets)))
+        targets = list(override_targets)
+        # All override targets are forced (bypass signature check)
+        forced_targets = override_targets
+    else:
+        # Read the delivery manifest from Redis
+        manifest_key = _delivery_manifest_key(ci_host, commit_sha, workspace)
+        print("")
+        print("Fetching delivery manifest: {}".format(manifest_key))
+        targets = _redis_lrange(ctx, redis_cfg, manifest_key, 0, -1)
+
+    if not targets:
+        print("No targets to deliver")
+        return 0
+
+    print("Found {} target(s) to deliver:".format(len(targets)))
+    for t in targets:
+        forced_marker = " (forced)" if t in forced_targets else ""
+        print("  - {}{}".format(t, forced_marker))
+    print("")
+
+    # Track results
+    success = []
+    skipped = []
+    build_failed = []
+    run_failed = []
+
+    for label in targets:
+        is_forced = label in forced_targets
+        status, message = _deliver_target(
+            ctx, redis_cfg, ci_host, commit_sha, workspace, build_url,
+            bazel_flags, label, is_forced
+        )
+
+        if status == "success":
+            success.append(label)
+            print("  [OK]   {}: {}".format(label, message))
+        elif status == "skipped":
+            skipped.append(label)
+            print("  [SKIP] {}: {}".format(label, message))
+        elif status == "build_failed":
+            build_failed.append(label)
+            print("  [FAIL] {}: {}".format(label, message))
+        else:  # run_failed
+            run_failed.append(label)
+            print("  [FAIL] {}: {}".format(label, message))
+
+    # Summary
+    print("")
+    print("=" * 50)
+    print("Delivery Summary")
+    print("=" * 50)
+    print("  Delivered: {}".format(len(success)))
+    print("  Skipped:   {}".format(len(skipped)))
+    print("  Failed:    {} ({} build, {} run)".format(
+        len(build_failed) + len(run_failed),
+        len(build_failed),
+        len(run_failed)
+    ))
+
+    if success:
+        print("")
+        print("Successfully delivered:")
+        for t in success:
+            print("  - {}".format(t))
+
+    if skipped:
+        print("")
+        print("Skipped (already delivered):")
+        for t in skipped:
+            print("  - {}".format(t))
+
+    if build_failed or run_failed:
+        print("")
+        print("Failed:")
+        for t in build_failed:
+            print("  - {} (build failed)".format(t))
+        for t in run_failed:
+            print("  - {} (run failed)".format(t))
+        return 1
+
+    return 0
+
+delivery = task(
+    name = "delivery",
+    implementation = _delivery_impl,
+    args = {
+        "host": args.string(default = "localhost"),
+        "port": args.string(default = "6379"),
+        "tls": args.boolean(default = False),
+        "ci_host": args.string(default = "bk"),
+        "commit_sha": args.string(),
+        "workspace": args.string(default = "."),
+        "build_url": args.string(),
+        "stamp_flags": args.string(default = "--stamp"),
+    },
+)
diff --git a/.aspect/modules/demo/MODULE.aspect b/.aspect/modules/demo/MODULE.aspect
index dbd41833d..2df3a5d96 100644
--- a/.aspect/modules/demo/MODULE.aspect
+++ b/.aspect/modules/demo/MODULE.aspect
@@ -1 +1,2 @@
-use_task("template_demo.axl", "template_demo")
\ No newline at end of file
+use_task("template_demo.axl", "template_demo")
+use_task("dummy.axl", "dummy")
\ No newline at end of file
diff --git a/.aspect/modules/demo/dummy.axl b/.aspect/modules/demo/dummy.axl
new file mode 100644
index 000000000..8d92eb5e3
--- /dev/null
+++ b/.aspect/modules/demo/dummy.axl
@@ -0,0 +1,44 @@
+# Test the spec type
+Person = spec(name=str, age=attr(int, 25))
+
+def _impl(ctx):
+    # Create a record instance with all fields
+    p1 = Person(name="Alice", age=30)
+    print("Person 1:", p1)
+    print("  name:", p1.name)
+    print("  age:", p1.age)
+
+    # Create a record instance using the default for age
+    p2 = Person(name="Bob")
+    print("Person 2:", p2)
+    print("  name:", p2.name)
+    print("  age:", p2.age, "(default)")
+
+    # Test field access via dir()
+    print("Fields:", dir(p1))
+
+    # Test equality
+    p3 = Person(name="Alice", age=30)
+    print("p1 == p3:", p1 == p3)
+    print("p1 == p2:", p1 == p2)
+
+    # Test mutation
+    print("\n--- Testing Mutation ---")
+    print("Before mutation: p1.age =", p1.age)
+    p1.age = 31
+    print("After mutation: p1.age =", p1.age)
+    print("p1 after mutation:", p1)
+
+    # Test type checking on mutation
+    print("\n--- Testing Type Checking on Mutation ---")
+    p1.name = "Alice Smith"
+    print("Changed name to:", p1.name)
+
+    print("\nAll tests passed!")
+    return 0
+
+dummy = task(
+    name = "dummy",
+    implementation = _impl,
+    args = {},
+)
diff --git a/.aspect/user-task.axl b/.aspect/user-task.axl
index 513fa2c74..60088d0b1 100644
--- a/.aspect/user-task.axl
+++ b/.aspect/user-task.axl
@@ -13,11 +13,18 @@ def _impl2(ctx):
     print("I am an auto-discovered task in .aspect/user-task.axl")
     return 0
 
+bindings = record(
+    callback = field(typing.Callable[[int], None], lambda _: None),
+    test = field(int, 0)
+)
+
+def untyped_bindings():
+    return struct()
+
+
 user_task3 = task(
     group = ["user"],
     implementation = _impl,
     args = {},
-    # config = config.type(
-    #     callback = typing.Callable[[]],
-    # )
+    binding = untyped_bindings
 )
diff --git a/crates/axl-runtime/src/engine/config/task_list/task_mut.rs b/crates/axl-runtime/src/engine/config/task_list/task_mut.rs
index 22e859582..35351a19b 100644
--- a/crates/axl-runtime/src/engine/config/task_list/task_mut.rs
+++ b/crates/axl-runtime/src/engine/config/task_list/task_mut.rs
@@ -87,20 +87,25 @@ impl<'v> values::StarlarkValue<'v> for TaskMut<'v> {
     }
 
     fn get_attr(&self, attribute: &str, heap: &'v Heap) -> Option<values::Value<'v>> {
+        eprintln!("{}", attribute == "binding");
         match attribute {
             "name" => Some(heap.alloc_str(self.name.borrow().as_str()).to_value()),
             "group" => Some(heap.alloc(AllocList(self.group.borrow().iter()))),
+            "binding" => {
+                if let Some(task) = self.original.downcast_ref::<Task>() {
+                    Some(task.binding())
+                } else if let Some(task) = self.original.downcast_ref::<FrozenTask>() {
+                    Some(task.binding())
+                } else {
+                    None
+                }
+            }
             _ => None,
         }
     }
 
     fn dir_attr(&self) -> Vec<String> {
-        vec![
-            "group".into(),
-            "name".into(),
-            "args".into(),
-            "config".into(),
-        ]
+        vec!["name".into(), "group".into(), "binding".into()]
     }
 }
 
diff --git a/crates/axl-runtime/src/engine/mod.rs b/crates/axl-runtime/src/engine/mod.rs
index f89fa8217..0801503f0 100644
--- a/crates/axl-runtime/src/engine/mod.rs
+++ b/crates/axl-runtime/src/engine/mod.rs
@@ -46,6 +46,7 @@ pub fn register_globals(globals: &mut GlobalsBuilder) {
     globals::register_globals(globals);
     r#async::register_globals(globals);
     task::register_globals(globals);
+    types::record::register_globals(globals);
 
     globals.namespace("args", task_arg::register_globals);
     globals.namespace("bazel", bazel::register_globals);
diff --git a/crates/axl-runtime/src/engine/task.rs b/crates/axl-runtime/src/engine/task.rs
index 55bbc3362..250cfeba0 100644
--- a/crates/axl-runtime/src/engine/task.rs
+++ b/crates/axl-runtime/src/engine/task.rs
@@ -5,12 +5,14 @@ use allocative::Allocative;
 use derive_more::Display;
 use starlark::collections::SmallMap;
 use starlark::environment::GlobalsBuilder;
+use starlark::eval::Evaluator;
 use starlark::starlark_module;
 use starlark::starlark_simple_value;
 use starlark::typing::ParamIsRequired;
 use starlark::typing::ParamSpec;
 use starlark::values;
 use starlark::values::list::UnpackList;
+use starlark::values::none::NoneOr;
 use starlark::values::none::NoneType;
 use starlark::values::starlark_value;
 use starlark::values::typing::StarlarkCallableParamSpec;
@@ -27,6 +29,7 @@ pub trait TaskLike<'v>: 'v {
     fn description(&self) -> &String;
     fn group(&self) -> &Vec<String>;
     fn name(&self) -> &String;
+    fn binding(&self) -> values::Value<'v>;
 }
 
 pub trait AsTaskLike<'v>: TaskLike<'v> {
@@ -46,6 +49,7 @@ where
 #[display("<Task>")]
 pub struct Task<'v> {
     r#impl: values::Value<'v>,
+    binding: values::Value<'v>,
     #[allocative(skip)]
     pub(super) args: SmallMap<String, TaskArg>,
     pub(super) description: String,
@@ -57,6 +61,9 @@ impl<'v> Task<'v> {
     pub fn implementation(&self) -> values::Value<'v> {
         self.r#impl
     }
+    pub fn binding(&self) -> values::Value<'v> {
+        self.binding
+    }
     pub fn args(&self) -> &SmallMap<String, TaskArg> {
         &self.args
     }
@@ -72,9 +79,13 @@ impl<'v> Task<'v> {
 }
 
 impl<'v> TaskLike<'v> for Task<'v> {
+    fn binding(&self) -> values::Value<'v> {
+        self.binding
+    }
     fn args(&self) -> &SmallMap<String, TaskArg> {
         &self.args
     }
+
     fn description(&self) -> &String {
         &self.description
     }
@@ -99,8 +110,10 @@ impl<'v> values::Freeze for Task<'v> {
     type Frozen = FrozenTask;
     fn freeze(self, freezer: &values::Freezer) -> values::FreezeResult<Self::Frozen> {
         let frozen_impl = self.r#impl.freeze(freezer)?;
+        let binding = self.binding.freeze(freezer)?;
         Ok(FrozenTask {
             args: self.args,
+            binding: binding,
             r#impl: frozen_impl,
             description: self.description,
             group: self.group,
@@ -113,6 +126,7 @@ impl<'v> values::Freeze for Task<'v> {
 #[display("<Task>")]
 pub struct FrozenTask {
     r#impl: values::FrozenValue,
+    binding: values::FrozenValue,
     #[allocative(skip)]
     pub(super) args: SmallMap<String, TaskArg>,
     pub(super) description: String,
@@ -134,6 +148,9 @@ impl FrozenTask {
 }
 
 impl<'v> TaskLike<'v> for FrozenTask {
+    fn binding(&self) -> values::Value<'v> {
+        self.binding.to_value()
+    }
     fn args(&self) -> &SmallMap<String, TaskArg> {
         &self.args
     }
@@ -190,7 +207,9 @@ pub fn register_globals(globals: &mut GlobalsBuilder) {
         #[starlark(require = named)] args: values::dict::UnpackDictEntries<&'v str, TaskArg>,
         #[starlark(require = named, default = String::new())] description: String,
         #[starlark(require = named, default = UnpackList::default())] group: UnpackList<String>,
+        #[starlark(require = named, default = NoneOr::None)] binding: NoneOr<values::Value<'v>>,
         #[starlark(require = named, default = String::new())] name: String,
+        eval: &mut Evaluator<'v, '_, '_>,
     ) -> starlark::Result<Task<'v>> {
         if group.items.len() > MAX_TASK_GROUPS {
             return Err(anyhow::anyhow!(
@@ -199,12 +218,19 @@ pub fn register_globals(globals: &mut GlobalsBuilder) {
             )
             .into());
         }
+        let binding = if let Some(binding) = binding.into_option() {
+            eval.eval_function(binding, &[], &[])?
+        } else {
+            Value::new_none()
+        };
+
         let mut args_ = SmallMap::new();
         for (arg, def) in args.entries {
             args_.insert(arg.to_owned(), def.clone());
         }
         Ok(Task {
             args: args_,
+            binding,
             r#impl: implementation.0,
             description,
             group: group.items,
diff --git a/crates/axl-runtime/src/engine/types/mod.rs b/crates/axl-runtime/src/engine/types/mod.rs
index ad0049c4c..9afd7fe17 100644
--- a/crates/axl-runtime/src/engine/types/mod.rs
+++ b/crates/axl-runtime/src/engine/types/mod.rs
@@ -1 +1,2 @@
 pub mod bytes;
+pub mod record;
diff --git a/crates/axl-runtime/src/engine/types/record.rs b/crates/axl-runtime/src/engine/types/record.rs
new file mode 100644
index 000000000..d51c14947
--- /dev/null
+++ b/crates/axl-runtime/src/engine/types/record.rs
@@ -0,0 +1,799 @@
+use std::cell::Cell;
+use std::fmt::{self, Display, Write};
+use std::sync::atomic::{AtomicU64, Ordering};
+
+use allocative::Allocative;
+use starlark::environment::{GlobalsBuilder, Methods, MethodsBuilder, MethodsStatic};
+use starlark::starlark_module;
+use starlark::values::typing::TypeCompiled;
+use starlark::values::{
+    starlark_value, AllocFrozenValue, AllocValue, Freeze, FreezeError, Freezer, FrozenHeap,
+    FrozenValue, Heap, NoSerialize, ProvidesStaticType, StarlarkValue, Trace, Tracer, Value,
+    ValueLike,
+};
+use starlark_map::small_map::SmallMap;
+
+static RECORD_TYPE_ID: AtomicU64 = AtomicU64::new(0);
+
+fn next_record_type_id() -> u64 {
+    RECORD_TYPE_ID.fetch_add(1, Ordering::SeqCst)
+}
+
+// -----------------------------------------------------------------------------
+// Field
+// -----------------------------------------------------------------------------
+
+/// A field definition for a record, containing a type and optional default value.
+#[derive(Debug, Clone, ProvidesStaticType, Allocative)]
+pub struct Field<'v> {
+    pub(crate) typ: TypeCompiled<Value<'v>>,
+    pub(crate) default: Option<Value<'v>>,
+}
+
+impl<'v> Display for Field<'v> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match &self.default {
+            None => write!(f, "field({})", self.typ),
+            Some(d) => write!(f, "field({}, {})", self.typ, d),
+        }
+    }
+}
+
+unsafe impl<'v> Trace<'v> for Field<'v> {
+    fn trace(&mut self, tracer: &Tracer<'v>) {
+        self.typ.trace(tracer);
+        if let Some(ref mut d) = self.default {
+            d.trace(tracer);
+        }
+    }
+}
+
+impl<'v> Field<'v> {
+    pub fn freeze(self, freezer: &Freezer) -> Result<FrozenField, FreezeError> {
+        Ok(FrozenField {
+            typ: self.typ.freeze(freezer)?,
+            default: self.default.map(|d| d.freeze(freezer)).transpose()?,
+        })
+    }
+}
+
+/// A frozen field definition.
+#[derive(Debug, Clone, ProvidesStaticType, Allocative)]
+pub struct FrozenField {
+    pub(crate) typ: TypeCompiled<FrozenValue>,
+    pub(crate) default: Option<FrozenValue>,
+}
+
+impl Display for FrozenField {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match &self.default {
+            None => write!(f, "field({})", self.typ),
+            Some(d) => write!(f, "field({}, {})", self.typ, d),
+        }
+    }
+}
+
+// -----------------------------------------------------------------------------
+// FieldValue - a wrapper for field() function return
+// -----------------------------------------------------------------------------
+
+#[derive(Debug, ProvidesStaticType, NoSerialize, Allocative)]
+pub struct FieldValue<'v> {
+    pub(crate) typ: TypeCompiled<Value<'v>>,
+    pub(crate) default: Option<Value<'v>>,
+}
+
+impl<'v> Display for FieldValue<'v> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match &self.default {
+            None => write!(f, "field({})", self.typ),
+            Some(d) => write!(f, "field({}, {})", self.typ, d),
+        }
+    }
+}
+
+unsafe impl<'v> Trace<'v> for FieldValue<'v> {
+    fn trace(&mut self, tracer: &Tracer<'v>) {
+        self.typ.trace(tracer);
+        if let Some(ref mut d) = self.default {
+            d.trace(tracer);
+        }
+    }
+}
+
+impl<'v> AllocValue<'v> for FieldValue<'v> {
+    fn alloc_value(self, heap: &'v Heap) -> Value<'v> {
+        heap.alloc_complex_no_freeze(self)
+    }
+}
+
+#[starlark_value(type = "field")]
+impl<'v> StarlarkValue<'v> for FieldValue<'v> {
+    fn collect_repr(&self, collector: &mut String) {
+        write!(collector, "{}", self).unwrap();
+    }
+}
+
+// -----------------------------------------------------------------------------
+// RecordType
+// -----------------------------------------------------------------------------
+
+/// The type of a record, created by `record(field1=type1, field2=type2, ...)`.
+/// Calling this type creates a `Record` instance.
+#[derive(Debug, ProvidesStaticType, NoSerialize, Allocative)]
+pub struct RecordType<'v> {
+    /// Unique identifier for this record type
+    pub(crate) id: u64,
+    /// Name of the record type (set when assigned to a variable)
+    pub(crate) name: Option<String>,
+    /// Fields with their types and optional defaults
+    pub(crate) fields: SmallMap<String, Field<'v>>,
+}
+
+impl<'v> Display for RecordType<'v> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match &self.name {
+            Some(name) => write!(f, "record[{}]", name),
+            None => write!(f, "record[anon]"),
+        }
+    }
+}
+
+unsafe impl<'v> Trace<'v> for RecordType<'v> {
+    fn trace(&mut self, tracer: &Tracer<'v>) {
+        for (_, field) in self.fields.iter_mut() {
+            field.trace(tracer);
+        }
+    }
+}
+
+impl<'v> AllocValue<'v> for RecordType<'v> {
+    fn alloc_value(self, heap: &'v Heap) -> Value<'v> {
+        heap.alloc_complex_no_freeze(self)
+    }
+}
+
+#[starlark_value(type = "record_type")]
+impl<'v> StarlarkValue<'v> for RecordType<'v> {
+    fn collect_repr(&self, collector: &mut String) {
+        write!(collector, "{}", self).unwrap();
+    }
+
+    fn export_as(
+        &self,
+        variable_name: &str,
+        _eval: &mut starlark::eval::Evaluator<'v, '_, '_>,
+    ) -> starlark::Result<()> {
+        // This is called when the record type is assigned to a variable.
+        // We use unsafe to mutate the name, which is safe because this is only
+        // called during module loading.
+        let this = self as *const Self as *mut Self;
+        unsafe {
+            (*this).name = Some(variable_name.to_string());
+        }
+        Ok(())
+    }
+
+    fn invoke(
+        &self,
+        _me: Value<'v>,
+        args: &starlark::eval::Arguments<'v, '_>,
+        eval: &mut starlark::eval::Evaluator<'v, '_, '_>,
+    ) -> starlark::Result<Value<'v>> {
+        // Parse the arguments according to our field definitions
+        let mut values: Vec<Cell<Value<'v>>> = Vec::with_capacity(self.fields.len());
+
+        // Get the named arguments
+        args.no_positional_args(eval.heap())?;
+        let kwargs = args.names_map()?;
+
+        // Build values in field order
+        for (field_name, field) in self.fields.iter() {
+            let value = if let Some(v) = kwargs.get(field_name.as_str()) {
+                *v
+            } else if let Some(default) = field.default {
+                default
+            } else {
+                return Err(starlark::Error::new_other(anyhow::anyhow!(
+                    "Missing required field `{}` for {}",
+                    field_name,
+                    self
+                )));
+            };
+
+            // Type check the value
+            if !field.typ.matches(value) {
+                return Err(starlark::Error::new_other(anyhow::anyhow!(
+                    "Field `{}` expected type `{}`, got `{}`",
+                    field_name,
+                    field.typ,
+                    value.get_type()
+                )));
+            }
+
+            values.push(Cell::new(value));
+        }
+
+        // Check for unexpected kwargs
+        for (name, _) in kwargs.iter() {
+            if !self.fields.contains_key(name.as_str()) {
+                return Err(starlark::Error::new_other(anyhow::anyhow!(
+                    "Unexpected field `{}` for {}",
+                    name,
+                    self
+                )));
+            }
+        }
+
+        let record = Record {
+            typ: _me,
+            values: values.into_boxed_slice(),
+        };
+        Ok(eval.heap().alloc(record))
+    }
+
+    fn get_methods() -> Option<&'static Methods> {
+        static RES: MethodsStatic = MethodsStatic::new();
+        RES.methods(record_type_methods)
+    }
+}
+
+#[starlark_module]
+fn record_type_methods(_builder: &mut MethodsBuilder) {}
+
+// -----------------------------------------------------------------------------
+// FrozenRecordType
+// -----------------------------------------------------------------------------
+
+/// Frozen version of RecordType.
+#[derive(Debug, ProvidesStaticType, NoSerialize, Allocative)]
+pub struct FrozenRecordType {
+    pub(crate) id: u64,
+    pub(crate) name: Option<String>,
+    pub(crate) fields: SmallMap<String, FrozenField>,
+}
+
+impl Display for FrozenRecordType {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match &self.name {
+            Some(name) => write!(f, "record[{}]", name),
+            None => write!(f, "record[anon]"),
+        }
+    }
+}
+
+unsafe impl<'v> Trace<'v> for FrozenRecordType {
+    fn trace(&mut self, _tracer: &Tracer<'v>) {
+        // Frozen values don't need tracing
+    }
+}
+
+impl AllocFrozenValue for FrozenRecordType {
+    fn alloc_frozen_value(self, heap: &FrozenHeap) -> FrozenValue {
+        heap.alloc_simple(self)
+    }
+}
+
+#[starlark_value(type = "record_type")]
+impl<'v> StarlarkValue<'v> for FrozenRecordType {
+    type Canonical = RecordType<'v>;
+
+    fn collect_repr(&self, collector: &mut String) {
+        write!(collector, "{}", self).unwrap();
+    }
+
+    fn invoke(
+        &self,
+        _me: Value<'v>,
+        args: &starlark::eval::Arguments<'v, '_>,
+        eval: &mut starlark::eval::Evaluator<'v, '_, '_>,
+    ) -> starlark::Result<Value<'v>> {
+        let mut values: Vec<Cell<Value<'v>>> = Vec::with_capacity(self.fields.len());
+
+        args.no_positional_args(eval.heap())?;
+        let kwargs = args.names_map()?;
+
+        for (field_name, field) in self.fields.iter() {
+            let value = if let Some(v) = kwargs.get(field_name.as_str()) {
+                *v
+            } else if let Some(default) = field.default {
+                default.to_value()
+            } else {
+                return Err(starlark::Error::new_other(anyhow::anyhow!(
+                    "Missing required field `{}` for {}",
+                    field_name,
+                    self
+                )));
+            };
+
+            // Type check using matches on the value representation
+            if !field.typ.matches(value) {
+                return Err(starlark::Error::new_other(anyhow::anyhow!(
+                    "Field `{}` expected type `{}`, got `{}`",
+                    field_name,
+                    field.typ,
+                    value.get_type()
+                )));
+            }
+
+            values.push(Cell::new(value));
+        }
+
+        for (name, _) in kwargs.iter() {
+            if !self.fields.contains_key(name.as_str()) {
+                return Err(starlark::Error::new_other(anyhow::anyhow!(
+                    "Unexpected field `{}` for {}",
+                    name,
+                    self
+                )));
+            }
+        }
+
+        let record = Record {
+            typ: _me,
+            values: values.into_boxed_slice(),
+        };
+        Ok(eval.heap().alloc(record))
+    }
+
+    fn get_methods() -> Option<&'static Methods> {
+        static RES: MethodsStatic = MethodsStatic::new();
+        RES.methods(record_type_methods)
+    }
+}
+
+impl Freeze for RecordType<'_> {
+    type Frozen = FrozenRecordType;
+
+    fn freeze(self, freezer: &Freezer) -> Result<Self::Frozen, FreezeError> {
+        let mut frozen_fields = SmallMap::with_capacity(self.fields.len());
+        for (name, field) in self.fields.into_iter() {
+            frozen_fields.insert(name, field.freeze(freezer)?);
+        }
+        Ok(FrozenRecordType {
+            id: self.id,
+            name: self.name,
+            fields: frozen_fields,
+        })
+    }
+}
+
+// -----------------------------------------------------------------------------
+// Record
+// -----------------------------------------------------------------------------
+
+/// An instance of a record type, containing field values.
+#[derive(Debug, ProvidesStaticType, NoSerialize, Allocative)]
+pub struct Record<'v> {
+    /// The record type this instance belongs to
+    pub(crate) typ: Value<'v>,
+    /// Field values in the same order as the type's field definitions (mutable via Cell)
+    #[allocative(skip)]
+    pub(crate) values: Box<[Cell<Value<'v>>]>,
+}
+
+impl<'v> Display for Record<'v> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{}(", self.typ)?;
+        if let Some(record_type) = self.typ.downcast_ref::<RecordType>() {
+            let mut first = true;
+            for ((name, _), value) in record_type.fields.iter().zip(self.values.iter()) {
+                if !first {
+                    write!(f, ", ")?;
+                }
+                first = false;
+                write!(f, "{}={}", name, value.get())?;
+            }
+        } else if let Some(frozen_type) = self.typ.downcast_ref::<FrozenRecordType>() {
+            let mut first = true;
+            for ((name, _), value) in frozen_type.fields.iter().zip(self.values.iter()) {
+                if !first {
+                    write!(f, ", ")?;
+                }
+                first = false;
+                write!(f, "{}={}", name, value.get())?;
+            }
+        }
+        write!(f, ")")
+    }
+}
+
+unsafe impl<'v> Trace<'v> for Record<'v> {
+    fn trace(&mut self, tracer: &Tracer<'v>) {
+        self.typ.trace(tracer);
+        for cell in self.values.iter() {
+            let mut v = cell.get();
+            v.trace(tracer);
+            cell.set(v);
+        }
+    }
+}
+
+impl<'v> AllocValue<'v> for Record<'v> {
+    fn alloc_value(self, heap: &'v Heap) -> Value<'v> {
+        heap.alloc_complex_no_freeze(self)
+    }
+}
+
+impl<'v> Record<'v> {
+    fn get_field_names(&self) -> Vec<&str> {
+        if let Some(record_type) = self.typ.downcast_ref::<RecordType>() {
+            record_type.fields.keys().map(|s| s.as_str()).collect()
+        } else if let Some(frozen_type) = self.typ.downcast_ref::<FrozenRecordType>() {
+            frozen_type.fields.keys().map(|s| s.as_str()).collect()
+        } else {
+            vec![]
+        }
+    }
+}
+
+#[starlark_value(type = "record")]
+impl<'v> StarlarkValue<'v> for Record<'v> {
+    fn collect_repr(&self, collector: &mut String) {
+        write!(collector, "{}", self).unwrap();
+    }
+
+    fn get_attr(&self, attribute: &str, _heap: &'v Heap) -> Option<Value<'v>> {
+        if let Some(record_type) = self.typ.downcast_ref::<RecordType>() {
+            if let Some(idx) = record_type.fields.get_index_of(attribute) {
+                return Some(self.values[idx].get());
+            }
+        } else if let Some(frozen_type) = self.typ.downcast_ref::<FrozenRecordType>() {
+            if let Some(idx) = frozen_type.fields.get_index_of(attribute) {
+                return Some(self.values[idx].get());
+            }
+        }
+        None
+    }
+
+    fn set_attr(&self, attribute: &str, value: Value<'v>) -> starlark::Result<()> {
+        // Get field info and index
+        let (idx, field_typ) = if let Some(record_type) = self.typ.downcast_ref::<RecordType>() {
+            if let Some(idx) = record_type.fields.get_index_of(attribute) {
+                (idx, &record_type.fields.get_index(idx).unwrap().1.typ)
+            } else {
+                return Err(starlark::Error::new_other(anyhow::anyhow!(
+                    "Record {} has no field `{}`",
+                    self.typ,
+                    attribute
+                )));
+            }
+        } else if let Some(frozen_type) = self.typ.downcast_ref::<FrozenRecordType>() {
+            if let Some(idx) = frozen_type.fields.get_index_of(attribute) {
+                // For frozen types, we need to check against the frozen field's type
+                let field = frozen_type.fields.get_index(idx).unwrap().1;
+                if !field.typ.matches(value) {
+                    return Err(starlark::Error::new_other(anyhow::anyhow!(
+                        "Field `{}` expected type `{}`, got `{}`",
+                        attribute,
+                        field.typ,
+                        value.get_type()
+                    )));
+                }
+                self.values[idx].set(value);
+                return Ok(());
+            } else {
+                return Err(starlark::Error::new_other(anyhow::anyhow!(
+                    "Record {} has no field `{}`",
+                    self.typ,
+                    attribute
+                )));
+            }
+        } else {
+            return Err(starlark::Error::new_other(anyhow::anyhow!(
+                "Invalid record type"
+            )));
+        };
+
+        // Type check the value
+        if !field_typ.matches(value) {
+            return Err(starlark::Error::new_other(anyhow::anyhow!(
+                "Field `{}` expected type `{}`, got `{}`",
+                attribute,
+                field_typ,
+                value.get_type()
+            )));
+        }
+
+        // Set the value
+        self.values[idx].set(value);
+        Ok(())
+    }
+
+    fn has_attr(&self, attribute: &str, _heap: &'v Heap) -> bool {
+        if let Some(record_type) = self.typ.downcast_ref::<RecordType>() {
+            record_type.fields.contains_key(attribute)
+        } else if let Some(frozen_type) = self.typ.downcast_ref::<FrozenRecordType>() {
+            frozen_type.fields.contains_key(attribute)
+        } else {
+            false
+        }
+    }
+
+    fn dir_attr(&self) -> Vec<String> {
+        self.get_field_names()
+            .into_iter()
+            .map(|s| s.to_string())
+            .collect()
+    }
+
+    fn equals(&self, other: Value<'v>) -> starlark::Result<bool> {
+        if let Some(other_record) = other.downcast_ref::<Record>() {
+            // Check that they have the same record type
+            let self_id = self
+                .typ
+                .downcast_ref::<RecordType>()
+                .map(|t| t.id)
+                .or_else(|| self.typ.downcast_ref::<FrozenRecordType>().map(|t| t.id));
+            let other_id = other_record
+                .typ
+                .downcast_ref::<RecordType>()
+                .map(|t| t.id)
+                .or_else(|| {
+                    other_record
+                        .typ
+                        .downcast_ref::<FrozenRecordType>()
+                        .map(|t| t.id)
+                });
+
+            if self_id != other_id {
+                return Ok(false);
+            }
+
+            // Compare all values
+            if self.values.len() != other_record.values.len() {
+                return Ok(false);
+            }
+            for (a, b) in self.values.iter().zip(other_record.values.iter()) {
+                if !a.get().equals(b.get())? {
+                    return Ok(false);
+                }
+            }
+            Ok(true)
+        } else if let Some(other_frozen) = other.downcast_ref::<FrozenRecord>() {
+            let self_id = self
+                .typ
+                .downcast_ref::<RecordType>()
+                .map(|t| t.id)
+                .or_else(|| self.typ.downcast_ref::<FrozenRecordType>().map(|t| t.id));
+            let other_id = other_frozen
+                .typ
+                .downcast_ref::<FrozenRecordType>()
+                .map(|t| t.id);
+
+            if self_id != other_id {
+                return Ok(false);
+            }
+
+            if self.values.len() != other_frozen.values.len() {
+                return Ok(false);
+            }
+            for (a, b) in self.values.iter().zip(other_frozen.values.iter()) {
+                if !a.get().equals(b.to_value())? {
+                    return Ok(false);
+                }
+            }
+            Ok(true)
+        } else {
+            Ok(false)
+        }
+    }
+}
+
+// -----------------------------------------------------------------------------
+// FrozenRecord
+// -----------------------------------------------------------------------------
+
+/// Frozen version of Record.
+#[derive(Debug, ProvidesStaticType, NoSerialize, Allocative)]
+pub struct FrozenRecord {
+    pub(crate) typ: FrozenValue,
+    pub(crate) values: Box<[FrozenValue]>,
+}
+
+impl Display for FrozenRecord {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{}(", self.typ)?;
+        if let Some(frozen_type) = self.typ.downcast_ref::<FrozenRecordType>() {
+            let mut first = true;
+            for ((name, _), value) in frozen_type.fields.iter().zip(self.values.iter()) {
+                if !first {
+                    write!(f, ", ")?;
+                }
+                first = false;
+                write!(f, "{}={}", name, value)?;
+            }
+        }
+        write!(f, ")")
+    }
+}
+
+unsafe impl<'v> Trace<'v> for FrozenRecord {
+    fn trace(&mut self, _tracer: &Tracer<'v>) {
+        // Frozen values don't need tracing
+    }
+}
+
+impl AllocFrozenValue for FrozenRecord {
+    fn alloc_frozen_value(self, heap: &FrozenHeap) -> FrozenValue {
+        heap.alloc_simple(self)
+    }
+}
+
+#[starlark_value(type = "record")]
+impl<'v> StarlarkValue<'v> for FrozenRecord {
+    type Canonical = Record<'v>;
+
+    fn collect_repr(&self, collector: &mut String) {
+        write!(collector, "{}", self).unwrap();
+    }
+
+    fn get_attr(&self, attribute: &str, _heap: &'v Heap) -> Option<Value<'v>> {
+        if let Some(frozen_type) = self.typ.downcast_ref::<FrozenRecordType>() {
+            if let Some(idx) = frozen_type.fields.get_index_of(attribute) {
+                return Some(self.values[idx].to_value());
+            }
+        }
+        None
+    }
+
+    fn has_attr(&self, attribute: &str, _heap: &'v Heap) -> bool {
+        if let Some(frozen_type) = self.typ.downcast_ref::<FrozenRecordType>() {
+            frozen_type.fields.contains_key(attribute)
+        } else {
+            false
+        }
+    }
+
+    fn dir_attr(&self) -> Vec<String> {
+        if let Some(frozen_type) = self.typ.downcast_ref::<FrozenRecordType>() {
+            frozen_type.fields.keys().map(|s| s.to_string()).collect()
+        } else {
+            vec![]
+        }
+    }
+
+    fn equals(&self, other: Value<'v>) -> starlark::Result<bool> {
+        if let Some(other_frozen) = other.downcast_ref::<FrozenRecord>() {
+            let self_id = self.typ.downcast_ref::<FrozenRecordType>().map(|t| t.id);
+            let other_id = other_frozen
+                .typ
+                .downcast_ref::<FrozenRecordType>()
+                .map(|t| t.id);
+
+            if self_id != other_id {
+                return Ok(false);
+            }
+
+            if self.values.len() != other_frozen.values.len() {
+                return Ok(false);
+            }
+            for (a, b) in self.values.iter().zip(other_frozen.values.iter()) {
+                if !a.to_value().equals(b.to_value())? {
+                    return Ok(false);
+                }
+            }
+            Ok(true)
+        } else if let Some(other_record) = other.downcast_ref::<Record>() {
+            let self_id = self.typ.downcast_ref::<FrozenRecordType>().map(|t| t.id);
+            let other_id = other_record
+                .typ
+                .downcast_ref::<RecordType>()
+                .map(|t| t.id)
+                .or_else(|| {
+                    other_record
+                        .typ
+                        .downcast_ref::<FrozenRecordType>()
+                        .map(|t| t.id)
+                });
+
+            if self_id != other_id {
+                return Ok(false);
+            }
+
+            if self.values.len() != other_record.values.len() {
+                return Ok(false);
+            }
+            for (a, b) in self.values.iter().zip(other_record.values.iter()) {
+                if !a.to_value().equals(b.get())? {
+                    return Ok(false);
+                }
+            }
+            Ok(true)
+        } else {
+            Ok(false)
+        }
+    }
+}
+
+impl Freeze for Record<'_> {
+    type Frozen = FrozenRecord;
+
+    fn freeze(self, freezer: &Freezer) -> Result<Self::Frozen, FreezeError> {
+        let typ = self.typ.freeze(freezer)?;
+        let values: Result<Vec<_>, _> = self
+            .values
+            .iter()
+            .map(|v| v.get().freeze(freezer))
+            .collect();
+        Ok(FrozenRecord {
+            typ,
+            values: values?.into_boxed_slice(),
+        })
+    }
+}
+
+// -----------------------------------------------------------------------------
+// Global functions
+// -----------------------------------------------------------------------------
+
+#[starlark_module]
+pub fn register_globals(globals: &mut GlobalsBuilder) {
+    /// Creates a record type with the given fields.
+    ///
+    /// Example:
+    /// ```starlark
+    /// MyRecord = spec(host=str, port=int)
+    /// r = MyRecord(host="localhost", port=80)
+    /// print(r.host)  # "localhost"
+    /// print(r.port)  # 80
+    /// ```
+    fn spec<'v>(
+        #[starlark(kwargs)] kwargs: SmallMap<&str, Value<'v>>,
+        eval: &mut starlark::eval::Evaluator<'v, '_, '_>,
+    ) -> starlark::Result<RecordType<'v>> {
+        let mut fields = SmallMap::with_capacity(kwargs.len());
+
+        for (name, value) in kwargs.into_iter() {
+            let field = if let Some(field_value) = value.downcast_ref::<FieldValue>() {
+                // It's already a field() definition
+                Field {
+                    typ: field_value.typ.dupe(),
+                    default: field_value.default,
+                }
+            } else {
+                // It's a type, convert to a field without default
+                let typ = TypeCompiled::new(value, eval.heap())?;
+                Field { typ, default: None }
+            };
+            fields.insert(name.to_string(), field);
+        }
+
+        Ok(RecordType {
+            id: next_record_type_id(),
+            name: None,
+            fields,
+        })
+    }
+
+    /// Creates a field definition with a type and optional default value.
+    ///
+    /// Example:
+    /// ```starlark
+    /// MyRecord = spec(host=str, port=attr(int, 80))
+    /// r = MyRecord(host="localhost")  # port defaults to 80
+    /// ```
+    fn attr<'v>(
+        #[starlark(require = pos)] typ: Value<'v>,
+        #[starlark(require = pos)] default: Option<Value<'v>>,
+        eval: &mut starlark::eval::Evaluator<'v, '_, '_>,
+    ) -> starlark::Result<FieldValue<'v>> {
+        let compiled_type = TypeCompiled::new(typ, eval.heap())?;
+
+        // Validate that the default matches the type if provided
+        if let Some(d) = default {
+            if !compiled_type.matches(d) {
+                return Err(starlark::Error::new_other(anyhow::anyhow!(
+                    "Default value `{}` does not match field type `{}`",
+                    d,
+                    compiled_type
+                )));
+            }
+        }
+
+        Ok(FieldValue {
+            typ: compiled_type,
+            default,
+        })
+    }
+}