Added quiet zone support to QR rendering

draw/backdrop.odin

@@ -765,14 +765,11 @@ compute_backdrop_group_work_region :: proc(
 	max_x += halo_logical
 	max_y += halo_logical
 
-	// Clamp the min corner to 0, but let the max corner's 6σ halo extend past the swapchain edge
-	// into the working texture's unused area (at factor > 1), capped to the texture extent. Keeps
-	// the composite's bilinear upsample off the unwritten texels just past a clamped edge.
-	downsample_factor := compute_backdrop_downsample_factor(sigma_logical)
-	phys_min_x := max(min_x * dpi, 0)
-	phys_min_y := max(min_y * dpi, 0)
-	phys_max_x := min(max_x * dpi, f32(swapchain_width * downsample_factor))
-	phys_max_y := min(max_y * dpi, f32(swapchain_height * downsample_factor))
+	// Convert to physical pixels and clamp to swapchain bounds.
+	phys_min_x := math.max(min_x * dpi, 0)
+	phys_min_y := math.max(min_y * dpi, 0)
+	phys_max_x := math.min(max_x * dpi, f32(swapchain_width))
+	phys_max_y := math.min(max_y * dpi, f32(swapchain_height))
 
 	if phys_max_x <= phys_min_x || phys_max_y <= phys_min_y do return 0, 0, 0, 0
 
@@ -871,18 +868,12 @@ run_backdrop_bracket :: proc(
 		working_w := (region_w + downsample_factor - 1) / downsample_factor
 		working_h := (region_h + downsample_factor - 1) / downsample_factor
 
-		// Clamp to the full texture extent (not cached/factor): the working textures are full
-		// swapchain res, so a factor-N group's halo can spill into the unused remainder. Writing it
-		// keeps the composite's bilinear upsample off unwritten texels at the right/bottom edge.
-		texture_width := pipeline.cached_width
-		texture_height := pipeline.cached_height
-		// Skip fully off-screen groups; also guards the unsigned clamps below from underflow.
-		if working_x >= texture_width || working_y >= texture_height {
-			i = group_end
-			continue
-		}
-		if working_x + working_w > texture_width do working_w = texture_width - working_x
-		if working_y + working_h > texture_height do working_h = texture_height - working_y
+		// Working textures are sized at min factor (2). At factor=4 we have only half the texture
+		// area available in each axis. Clamp to the texture extent for either case.
+		wt_w := pipeline.cached_width / downsample_factor
+		wt_h := pipeline.cached_height / downsample_factor
+		if working_x + working_w > wt_w do working_w = wt_w - working_x
+		if working_y + working_h > wt_h do working_h = wt_h - working_y
 		if working_w == 0 || working_h == 0 {
 			i = group_end
 			continue

draw/clay.odin

@@ -730,9 +730,21 @@ flush_deferred_and_close_backdrop_scope :: proc(
 prepare_clay_batch :: proc(
 	base_layer: ^Layer,
 	batch: ^ClayBatch,
+	mouse_wheel_delta: [2]f32,
+	frame_time: f32 = 0,
 	custom_draw: Custom_Draw = nil,
 	temp_allocator := context.temp_allocator,
 ) {
+	mouse_pos: [2]f32
+	mouse_flags := sdl.GetMouseState(&mouse_pos.x, &mouse_pos.y)
+
+	// Update clay internals
+	clay.SetPointerState(
+		clay.Vector2{mouse_pos.x - base_layer.bounds.x, mouse_pos.y - base_layer.bounds.y},
+		.LEFT in mouse_flags,
+	)
+	clay.UpdateScrollContainers(true, mouse_wheel_delta, frame_time)
+
 	layer := base_layer
 	command_count := int(batch.cmds.length)
 	deferred_indices := make([dynamic]i32, 0, 16, temp_allocator)

draw/examples/clay_borders.odin

@@ -314,7 +314,7 @@ clay_borders :: proc() {
 			bounds = base_layer.bounds,
 			cmds   = clay.EndLayout(0),
 		}
-		draw.prepare_clay_batch(base_layer, &clay_batch)
+		draw.prepare_clay_batch(base_layer, &clay_batch, {0, 0})
 		draw.end(gpu, window)
 	}
 }

draw/examples/hellope.odin

@@ -259,7 +259,7 @@ hellope_clay :: proc() {
 			bounds = base_layer.bounds,
 			cmds   = clay.EndLayout(0),
 		}
-		draw.prepare_clay_batch(base_layer, &clay_batch)
+		draw.prepare_clay_batch(base_layer, &clay_batch, {0, 0})
 		draw.end(gpu, window)
 	}
 }
@@ -372,7 +372,7 @@ hellope_custom :: proc() {
 			bounds = base_layer.bounds,
 			cmds   = clay.EndLayout(0),
 		}
-		draw.prepare_clay_batch(base_layer, &clay_batch, custom_draw = draw_custom)
+		draw.prepare_clay_batch(base_layer, &clay_batch, {0, 0}, custom_draw = draw_custom)
 		draw.end(gpu, window)
 	}
 

levsync/levsync.odin

@@ -120,52 +120,10 @@ spinlock_try_lock :: #force_inline proc "contextless" (lock: ^Spinlock) -> bool
 	return lock_acquired
 }
 
-// Spins until the lock is acquired, relaxing the CPU between attempts.
-spinlock_lock :: #force_inline proc "contextless" (lock: ^Spinlock) {
-	for !spinlock_try_lock(lock) {
-		intrinsics.cpu_relax()
-	}
-}
-
 spinlock_unlock :: #force_inline proc "contextless" (lock: ^Spinlock) {
 	intrinsics.atomic_store_explicit(lock, false, .Release)
 }
 
-// Spins until the lock is acquired, then unlocks at the end of the calling scope. Always returns
-// true so it can guard a critical section from within an `if`:
-//
-//	if spinlock_guard(&lock) {
-//		// critical section
-//	}
-@(deferred_in = spinlock_unlock)
-spinlock_guard :: #force_inline proc "contextless" (lock: ^Spinlock) -> bool {
-	spinlock_lock(lock)
-	return true
-}
-
-// Tries to acquire the lock once without spinning. Returns true and unlocks at the end of the
-// calling scope if acquired, otherwise returns false and does nothing:
-//
-//	if spinlock_try_guard(&lock) {
-//		// critical section, entered only if the lock was acquired
-//	}
-@(deferred_in_out = spinlock_try_guard_unlock)
-spinlock_try_guard :: #force_inline proc "contextless" (lock: ^Spinlock) -> bool {
-	return spinlock_try_lock(lock)
-}
-
-// Deferred companion of `spinlock_try_guard`; unlocks only when the lock was actually acquired.
-@(private)
-spinlock_try_guard_unlock :: #force_inline proc "contextless" (lock: ^Spinlock, locked: bool) {
-	if locked {
-		spinlock_unlock(lock)
-	}
-}
-
-lock :: proc {
-	spinlock_lock,
-}
-
 try_lock :: proc {
 	spinlock_try_lock,
 }
@@ -174,14 +132,6 @@ unlock :: proc {
 	spinlock_unlock,
 }
 
-guard :: proc {
-	spinlock_guard,
-}
-
-try_guard :: proc {
-	spinlock_try_guard,
-}
-
 // ---------------------------------------------------------------------------------------------------------------------
 // ----- Tests ------------------------
 // ---------------------------------------------------------------------------------------------------------------------
@@ -189,10 +139,10 @@ import "core:sync"
 import "core:testing"
 import "core:thread"
 
-// Multiple threads will each add 1.0 this many times.
-// If any updates are lost due to race conditions, the final sum will be wrong.
 @(test)
 test_concurrent_atomic_add_no_lost_updates :: proc(t: ^testing.T) {
+	// Multiple threads will each add 1.0 this many times.
+	// If any updates are lost due to race conditions, the final sum will be wrong.
 	NUM_THREADS :: 8
 	ITERATIONS_PER_THREAD :: 10_000
 
@@ -234,10 +184,10 @@ test_concurrent_atomic_add_no_lost_updates :: proc(t: ^testing.T) {
 	testing.expect_value(t, shared_value, expected)
 }
 
-// Start with a known value, multiple threads subtract.
-// If any updates are lost due to race conditions, the final result will be wrong.
 @(test)
 test_concurrent_atomic_sub_no_lost_updates :: proc(t: ^testing.T) {
+	// Start with a known value, multiple threads subtract.
+	// If any updates are lost due to race conditions, the final result will be wrong.
 	NUM_THREADS :: 8
 	ITERATIONS_PER_THREAD :: 10_000
 
@@ -278,11 +228,11 @@ test_concurrent_atomic_sub_no_lost_updates :: proc(t: ^testing.T) {
 	testing.expect_value(t, shared_value, 0.0)
 }
 
-// Each thread multiplies by 2.0 then divides by 2.0.
-// Since these are inverses, the final value should equal the starting value
-// regardless of how operations interleave.
 @(test)
 test_concurrent_atomic_mul_div_round_trip :: proc(t: ^testing.T) {
+	// Each thread multiplies by 2.0 then divides by 2.0.
+	// Since these are inverses, the final value should equal the starting value
+	// regardless of how operations interleave.
 	NUM_THREADS :: 8
 	ITERATIONS_PER_THREAD :: 10_000
 
@@ -324,10 +274,10 @@ test_concurrent_atomic_mul_div_round_trip :: proc(t: ^testing.T) {
 	testing.expect_value(t, shared_value, 1000.0)
 }
 
-// Verify the f32 type dispatch works correctly under contention.
-// Same approach as the f64 add test but with f32.
 @(test)
 test_atomic_add_with_f32 :: proc(t: ^testing.T) {
+	// Verify the f32 type dispatch works correctly under contention.
+	// Same approach as the f64 add test but with f32.
 	NUM_THREADS :: 8
 	ITERATIONS_PER_THREAD :: 10_000
 
@@ -369,17 +319,17 @@ test_atomic_add_with_f32 :: proc(t: ^testing.T) {
 	testing.expect_value(t, shared_value, expected)
 }
 
-// Tests that the memory order passed to atomic_float_op's CAS success condition
-// provides full ordering guarantees for the entire float operation.
-//
-// Both sides use atomic_add_float (not raw intrinsics) to verify:
-// - Release on CAS success publishes prior non-atomic writes
-// - Acquire on CAS success makes those writes visible to the reader
-//
-// NOTE: This test may pass even with Relaxed ordering on x86 due to its strong memory model.
-// On ARM or other weak-memory architectures, using Relaxed here would likely cause failures.
 @(test)
 test_atomic_release_acquire_publish_visibility :: proc(t: ^testing.T) {
+	// Tests that the memory order passed to atomic_float_op's CAS success condition
+	// provides full ordering guarantees for the entire float operation.
+	//
+	// Both sides use atomic_add_float (not raw intrinsics) to verify:
+	// - Release on CAS success publishes prior non-atomic writes
+	// - Acquire on CAS success makes those writes visible to the reader
+	//
+	// NOTE: This test may pass even with Relaxed ordering on x86 due to its strong memory model.
+	// On ARM or other weak-memory architectures, using Relaxed here would likely cause failures.
 	NUM_READERS :: 4
 
 	Shared_State :: struct {
@@ -476,20 +426,17 @@ test_atomic_release_acquire_publish_visibility :: proc(t: ^testing.T) {
 	}
 }
 
-// Stress test for every spinlock acquisition variant: N threads contend on a
-// single lock and perform a deliberate non-atomic read-modify-write on shared
-// data. Each iteration rotates through spinlock_try_lock, spinlock_lock,
-// spinlock_guard, and spinlock_try_guard so every variant runs concurrently and
-// must uphold mutual exclusion on the same lock.
-//
-// If mutual exclusion holds:
-//   - `counter` ends at exactly NUM_THREADS * ITERATIONS_PER_THREAD
-//   - `concurrent_holders` never exceeds 1
-//
-// A multi-step RMW (read → relax → write) widens the critical section so
-// any failure to exclude is virtually guaranteed to corrupt the counter.
 @(test)
-test_spinlock_mutual_exclusion :: proc(t: ^testing.T) {
+test_spinlock_try_lock_mutual_exclusion :: proc(t: ^testing.T) {
+	// Stress test for spinlock_try_lock: N threads spin-acquire the lock and
+	// perform a deliberate non-atomic read-modify-write on shared data.
+	//
+	// If mutual exclusion holds:
+	//   - `counter` ends at exactly NUM_THREADS * ITERATIONS_PER_THREAD
+	//   - `concurrent_holders` never exceeds 1
+	//
+	// A multi-step RMW (read → relax → write) widens the critical section so
+	// any failure to exclude is virtually guaranteed to corrupt the counter.
 	NUM_THREADS :: 8
 	ITERATIONS_PER_THREAD :: 50_000
 
@@ -514,29 +461,6 @@ test_spinlock_mutual_exclusion :: proc(t: ^testing.T) {
 	barrier: sync.Barrier
 	sync.barrier_init(&barrier, NUM_THREADS)
 
-	// The single critical section every acquisition variant must protect. Sharing
-	// it guarantees they all stress the exact same non-atomic read-modify-write.
-	critical_section :: proc(s: ^Shared) {
-		// Atomically bump the holder count so we can detect overlapping holders.
-		holders := intrinsics.atomic_add_explicit(&s.concurrent_holders, 1, .Relaxed)
-
-		// Track the maximum we ever observed (relaxed is fine, this is
-		// purely diagnostic and protected by the spinlock for writes).
-		if holders + 1 > s.max_holders {
-			s.max_holders = holders + 1
-		}
-
-		// Non-atomic RMW: read, spin a tiny bit, then write.
-		// This deliberately creates a wide window where a second holder
-		// would cause a lost update.
-		val := s.counter
-		intrinsics.cpu_relax()
-		intrinsics.cpu_relax()
-		s.counter = val + 1
-
-		intrinsics.atomic_sub_explicit(&s.concurrent_holders, 1, .Relaxed)
-	}
-
 	thread_proc :: proc(th: ^thread.Thread) {
 		ctx := cast(^Thread_Data)th.data
 		s := ctx.shared
@@ -544,35 +468,36 @@ test_spinlock_mutual_exclusion :: proc(t: ^testing.T) {
 		// All threads rendezvous here for maximum contention.
 		sync.barrier_wait(ctx.barrier)
 
-		for i in 0 ..< ITERATIONS_PER_THREAD {
-			// Rotate through every acquisition variant so they all contend on the
-			// same lock simultaneously and must each uphold mutual exclusion.
-			switch i & 3 {
-			case 0:
-				// Manual spin on try_lock until we acquire it.
-				for !spinlock_try_lock(&s.lock) {
-					intrinsics.cpu_relax()
-				}
-				critical_section(s)
-				spinlock_unlock(&s.lock)
-			case 1:
-				// Blocking lock that loops internally until acquired.
-				spinlock_lock(&s.lock)
-				critical_section(s)
-				spinlock_unlock(&s.lock)
-			case 2: // Scoped guard: unlocks automatically at the end of the block.
-					if spinlock_guard(&s.lock) {
-						critical_section(s)
-					}
-			case 3: // Scoped try-guard: retry until acquired, auto-unlocks on success.
-					for {
-						if spinlock_try_guard(&s.lock) {
-							critical_section(s)
-							break
-						}
-						intrinsics.cpu_relax()
-					}
+		for _ in 0 ..< ITERATIONS_PER_THREAD {
+			// Spin on try_lock until we acquire it.
+			for !spinlock_try_lock(&s.lock) {
+				intrinsics.cpu_relax()
 			}
+
+			// --- critical section start ---
+
+			// Atomically bump the holder count so we can detect overlapping holders.
+			holders := intrinsics.atomic_add_explicit(&s.concurrent_holders, 1, .Relaxed)
+
+			// Track the maximum we ever observed (relaxed is fine, this is
+			// purely diagnostic and protected by the spinlock for writes).
+			if holders + 1 > s.max_holders {
+				s.max_holders = holders + 1
+			}
+
+			// Non-atomic RMW: read, spin a tiny bit, then write.
+			// This deliberately creates a wide window where a second holder
+			// would cause a lost update.
+			val := s.counter
+			intrinsics.cpu_relax()
+			intrinsics.cpu_relax()
+			s.counter = val + 1
+
+			intrinsics.atomic_sub_explicit(&s.concurrent_holders, 1, .Relaxed)
+
+			// --- critical section end ---
+
+			spinlock_unlock(&s.lock)
 		}
 	}
 

quantity/volume.odin

@@ -2,8 +2,6 @@ package quantity
 
 import "base:intrinsics"
 
-LITERS_PER_GALLON :: 3.785411784
-
 //----- Liters ----------------------------------
 Liters :: struct($V: typeid) where intrinsics.type_is_numeric(V) {
 	v: V,
@@ -11,16 +9,9 @@ Liters :: struct($V: typeid) where intrinsics.type_is_numeric(V) {
 
 @(private = "file")
 liters_to_milli_liters :: #force_inline proc "contextless" (
-	liters: Liters($V),
+    liters: Liters($V),
 ) -> Milli_Liters(V) where intrinsics.type_is_numeric(V) {
-	return Milli_Liters(V){liters.v * MILLI}
-}
-
-@(private = "file")
-liters_to_gallons :: #force_inline proc "contextless" (
-	liters: Liters($V),
-) -> Gallons(V) where intrinsics.type_is_float(V) {
-	return Gallons(V){liters.v / LITERS_PER_GALLON}
+    return Milli_Liters(V){liters.v * MILLI}
 }
 
 //----- Milliliters ----------------------------------
@@ -35,32 +26,15 @@ milli_liters_to_liters :: #force_inline proc "contextless" (
 	return Liters(V){milli_liters.v / MILLI}
 }
 
-//----- Gallons ----------------------------------
-Gallons :: struct($V: typeid) where intrinsics.type_is_numeric(V) {
-	v: V,
-}
-
-@(private = "file")
-gallons_to_liters :: #force_inline proc "contextless" (
-	gallons: Gallons($V),
-) -> Liters(V) where intrinsics.type_is_float(V) {
-	return Liters(V){gallons.v * LITERS_PER_GALLON}
-}
-
 // ---------------------------------------------------------------------------------------------------------------------
 // ----- Conversion Overloads ------------------------
 // ---------------------------------------------------------------------------------------------------------------------
 to_liters :: proc {
-	milli_liters_to_liters,
-	gallons_to_liters,
+    milli_liters_to_liters,
 }
 
 to_milli_liters :: proc {
-	liters_to_milli_liters,
-}
-
-to_gallons :: proc {
-	liters_to_gallons,
+    liters_to_milli_liters,
 }
 
 // ---------------------------------------------------------------------------------------------------------------------
@@ -70,32 +44,16 @@ import "core:testing"
 
 @(test)
 test_liters_to_milli_liters :: proc(t: ^testing.T) {
-	liters := Liters(int){12}
-	milli_liters := to_milli_liters(liters)
+    liters := Liters(int){12}
+    milli_liters := to_milli_liters(liters)
 
-	testing.expect_value(t, milli_liters, Milli_Liters(int){12_000})
+    testing.expect_value(t, milli_liters, Milli_Liters(int){12_000})
 }
 
 @(test)
 test_milli_liters_to_liters :: proc(t: ^testing.T) {
-	milli_liters := Milli_Liters(int){12_000}
-	liters := to_liters(milli_liters)
+    milli_liters := Milli_Liters(int){12_000}
+    liters := to_liters(milli_liters)
 
-	testing.expect_value(t, liters, Liters(int){12})
-}
-
-@(test)
-test_gallons_to_liters :: proc(t: ^testing.T) {
-	gallons := Gallons(f32){1}
-	liters := to_liters(gallons)
-
-	testing.expect(t, liters.v > 3.78 && liters.v < 3.79)
-}
-
-@(test)
-test_liters_to_gallons :: proc(t: ^testing.T) {
-	liters := Liters(f32){3.785411784}
-	gallons := to_gallons(liters)
-
-	testing.expect(t, gallons.v > 0.99 && gallons.v < 1.01)
+    testing.expect_value(t, liters, Liters(int){12})
 }

quantity/volume_rate.odin

@@ -2,58 +2,6 @@ package quantity
 
 import "base:intrinsics"
 
-//----- Liters Per Minute ----------------------------------
 Liters_Per_Minute :: struct($V: typeid) where intrinsics.type_is_numeric(V) {
 	v: V,
 }
-
-@(private = "file")
-liters_per_minute_to_gallons_per_minute :: #force_inline proc "contextless" (
-	liters_per_minute: Liters_Per_Minute($V),
-) -> Gallons_Per_Minute(V) where intrinsics.type_is_float(V) {
-	return Gallons_Per_Minute(V){liters_per_minute.v / LITERS_PER_GALLON}
-}
-
-//----- Gallons Per Minute ----------------------------------
-Gallons_Per_Minute :: struct($V: typeid) where intrinsics.type_is_numeric(V) {
-	v: V,
-}
-
-@(private = "file")
-gallons_per_minute_to_liters_per_minute :: #force_inline proc "contextless" (
-	gallons_per_minute: Gallons_Per_Minute($V),
-) -> Liters_Per_Minute(V) where intrinsics.type_is_float(V) {
-	return Liters_Per_Minute(V){gallons_per_minute.v * LITERS_PER_GALLON}
-}
-
-// ---------------------------------------------------------------------------------------------------------------------
-// ----- Conversion Overloads ------------------------
-// ---------------------------------------------------------------------------------------------------------------------
-to_liters_per_minute :: proc {
-	gallons_per_minute_to_liters_per_minute,
-}
-
-to_gallons_per_minute :: proc {
-	liters_per_minute_to_gallons_per_minute,
-}
-
-// ---------------------------------------------------------------------------------------------------------------------
-// ----- Tests ------------------------
-// ---------------------------------------------------------------------------------------------------------------------
-import "core:testing"
-
-@(test)
-test_gallons_per_minute_to_liters_per_minute :: proc(t: ^testing.T) {
-	gallons_per_minute := Gallons_Per_Minute(f32){1}
-	liters_per_minute := to_liters_per_minute(gallons_per_minute)
-
-	testing.expect(t, liters_per_minute.v > 3.78 && liters_per_minute.v < 3.79)
-}
-
-@(test)
-test_liters_per_minute_to_gallons_per_minute :: proc(t: ^testing.T) {
-	liters_per_minute := Liters_Per_Minute(f32){3.785411784}
-	gallons_per_minute := to_gallons_per_minute(liters_per_minute)
-
-	testing.expect(t, gallons_per_minute.v > 0.99 && gallons_per_minute.v < 1.01)
-}

vendor/lmdb/examples/examples.odin

@@ -68,9 +68,9 @@ main :: proc() {
 	db_handle: mdb.Dbi
 	// Put transaction
 	key := 7
-	key_val := mdb.pod_val(&key)
+	key_val := mdb.blittable_val(&key)
 	put_data := 12
-	put_data_val := mdb.pod_val(&put_data)
+	put_data_val := mdb.blittable_val(&put_data)
 	mdb.panic_on_err(mdb.txn_begin(environment, nil, {}, &txn_handle))
 	mdb.panic_on_err(mdb.dbi_open(txn_handle, nil, {}, &db_handle))
 	mdb.panic_on_err(mdb.put(txn_handle, db_handle, &key_val, &put_data_val, {}))
@@ -80,7 +80,7 @@ main :: proc() {
 	data_val: mdb.Val
 	mdb.panic_on_err(mdb.txn_begin(environment, nil, {}, &txn_handle))
 	mdb.panic_on_err(mdb.get(txn_handle, db_handle, &key_val, &data_val))
-	data_cpy := mdb.pod_copy(data_val, int)
-	mdb.txn_abort(txn_handle)
+	data_cpy := mdb.blittable_copy(&data_val, int)
+	mdb.panic_on_err(mdb.txn_commit(txn_handle))
 	fmt.println("Get result:", data_cpy)
 }

vendor/lmdb/lmdb.odin

@@ -169,86 +169,58 @@ import "core:fmt"
 import "core:reflect"
 import "core:sys/posix"
 
-import b "../../basic"
-
 // ---------------------------------------------------------------------------------------------------------------------
 // ----- Added Odin Helpers ------------------------
 // ---------------------------------------------------------------------------------------------------------------------
 
-// Wrap a POD value's bytes as an LMDB Val.
+// Wrap a blittable value's bytes as an LMDB Val.
 // T must be a contiguous type with no indirection (no pointers, slices, strings, maps, etc.).
-pod_val :: #force_inline proc(val_ptr: ^$T) -> Val {
-	when ODIN_DEBUG {
-		fmt.assertf(
-			reflect.has_no_indirections(type_info_of(T)),
-			"pod_val: type '%v' contains indirection and cannot be stored directly in LMDB",
-			typeid_of(T),
-		)
-	}
+blittable_val :: #force_inline proc(val_ptr: ^$T) -> Val {
+	fmt.assertf(
+		reflect.has_no_indirections(type_info_of(T)),
+		"blitval: type '%v' contains indirection and cannot be stored directly in LMDB",
+		typeid_of(T),
+	)
 	return Val{size_of(T), val_ptr}
 }
 
-// Reads a POD T out of the LMDB memory map by copying it into caller
+// Reads a blittable T out of the LMDB memory map by copying it into caller
 // storage. The returned T has no lifetime tie to the transaction.
-pod_copy :: #force_inline proc(val: Val, $T: typeid) -> T {
-	when ODIN_DEBUG {
-		fmt.assertf(
-			reflect.has_no_indirections(type_info_of(T)),
-			"pod_copy: type '%v' contains indirection and cannot be read directly from LMDB",
-			typeid_of(T),
-		)
-	}
-	when b.ODIN_BOUNDS_CHECK {
-		fmt.assertf(
-			val.size == size_of(T),
-			"size_of(%v) (%v) != val.size (%v)",
-			typeid_of(T),
-			size_of(T),
-			val.size,
-		)
-	}
+blittable_copy :: #force_inline proc(val: ^Val, $T: typeid) -> T {
+	fmt.assertf(
+		reflect.has_no_indirections(type_info_of(T)),
+		"blitval_copy: type '%v' contains indirection and cannot be read directly from LMDB",
+		typeid_of(T),
+	)
 	return (cast(^T)val.data)^
 }
 
 // Zero-copy pointer view into the LMDB memory map as a ^T.
-// Useful for large POD types where you want to read individual fields
+// Useful for large blittable types where you want to read individual fields
 // without copying the entire value (e.g. ptr.timestamp, ptr.flags).
 // MUST NOT be written through — writes either segfault (default env mode)
 // or silently corrupt the database (ENV_WRITEMAP).
 // MUST NOT be retained past txn_commit, txn_abort, or any subsequent write
 // operation on the same env — the pointer is invalidated.
-pod_view :: #force_inline proc(val: Val, $T: typeid) -> ^T {
-	when ODIN_DEBUG {
-		fmt.assertf(
-			reflect.has_no_indirections(type_info_of(T)),
-			"pod_view: type '%v' contains indirection and cannot be viewed directly from LMDB",
-			typeid_of(T),
-		)
-	}
-	when b.ODIN_BOUNDS_CHECK {
-		fmt.assertf(
-			val.size == size_of(T),
-			"size_of(%v) (%v) != val.size (%v)",
-			typeid_of(T),
-			size_of(T),
-			val.size,
-		)
-	}
+blittable_view :: #force_inline proc(val: ^Val, $T: typeid) -> ^T {
+	fmt.assertf(
+		reflect.has_no_indirections(type_info_of(T)),
+		"blitval_view: type '%v' contains indirection and cannot be viewed directly from LMDB",
+		typeid_of(T),
+	)
 	return cast(^T)val.data
 }
 
-// Wrap a slice of POD elements as an LMDB Val for use with put/get.
+// Wrap a slice of blittable elements as an LMDB Val for use with put/get.
 // T must be a contiguous type with no indirection.
 // The caller's slice must remain valid (not freed, not resized) for the
 // duration of the put call that consumes this Val.
-pod_slice_val :: #force_inline proc(s: []$T) -> Val {
-	when ODIN_DEBUG {
-		fmt.assertf(
-			reflect.has_no_indirections(type_info_of(T)),
-			"pod_slice_val: element type '%v' contains indirection and cannot be stored directly in LMDB",
-			typeid_of(T),
-		)
-	}
+slice_val :: #force_inline proc(s: []$T) -> Val {
+	fmt.assertf(
+		reflect.has_no_indirections(type_info_of(T)),
+		"slice_val: element type '%v' contains indirection and cannot be stored directly in LMDB",
+		typeid_of(T),
+	)
 	return Val{uint(len(s) * size_of(T)), raw_data(s)}
 }
 
@@ -259,21 +231,12 @@ pod_slice_val :: #force_inline proc(s: []$T) -> Val {
 // MUST be copied (e.g. slice.clone) if it needs to outlive the current
 // transaction; the view is invalidated by txn_commit, txn_abort, or any
 // subsequent write operation on the same env.
-pod_slice_view :: #force_inline proc(val: Val, $T: typeid) -> []T {
-	when ODIN_DEBUG {
-		fmt.assertf(
-			reflect.has_no_indirections(type_info_of(T)),
-			"pod_slice_view: element type '%v' contains indirection and cannot be read directly from LMDB",
-			typeid_of(T),
-		)
-		fmt.assertf(
-			val.size % size_of(T) == 0,
-			"pod_slice_view: val.size (%v) is not a multiple of size_of(%v) (%v)",
-			val.size,
-			typeid_of(T),
-			size_of(T),
-		)
-	}
+slice_view :: #force_inline proc(val: ^Val, $T: typeid) -> []T {
+	fmt.assertf(
+		reflect.has_no_indirections(type_info_of(T)),
+		"slice_view: element type '%v' contains indirection and cannot be read directly from LMDB",
+		typeid_of(T),
+	)
 	return (cast([^]T)val.data)[:val.size / size_of(T)]
 }
 
@@ -290,7 +253,7 @@ string_val :: #force_inline proc(s: string) -> Val {
 // MUST be copied (e.g. strings.clone) if it needs to outlive the current
 // transaction; the view is invalidated by txn_commit, txn_abort, or any
 // subsequent write operation on the same env.
-string_view :: #force_inline proc(val: Val) -> string {
+string_view :: #force_inline proc(val: ^Val) -> string {
 	return string((cast([^]u8)val.data)[:val.size])
 }