diff --git a/store.go b/store.go
index 9857a24..d209c6f 100644
--- a/store.go
+++ b/store.go
@@ -38,9 +38,18 @@
 type StoreCallbacks struct {
 	BeforeItemWrite, AfterItemRead ItemCallback
 
-	ItemValLength func(i *Item) int // On-disk size, in bytes, of an item's value.
-	ItemValWrite  func(i *Item, w io.WriterAt, offset int64) error
-	ItemValRead   func(i *Item, r io.ReaderAt, offset int64, valLength uint32) error
+	// Optional callback to control on-disk size, in bytes, of an item's value.
+	ItemValLength func(c *Collection, i *Item) int
+
+	// Optional callback to allow write item bytes differently.
+	ItemValWrite func(c *Collection, i *Item,
+		w io.WriterAt, offset int64) error
+
+	// Optional callback to read item bytes differently.  For example,
+	// the app might have an optimization to just remember the reader
+	// & file offsets in the item.Transient field.
+	ItemValRead func(c *Collection, i *Item,
+		r io.ReaderAt, offset int64, valLength uint32) error
 
 	// Invoked when a Store is reloaded (during NewStoreEx()) from
 	// disk, this callback allows the user to optionally supply a key
@@ -49,7 +58,7 @@
 	KeyCompareForCollection func(collName string) KeyCompare
 }
 
-type ItemCallback func(*Item) (*Item, error)
+type ItemCallback func(*Collection, *Item) (*Item, error)
 
 const VERSION = uint32(4)
 
@@ -423,13 +432,13 @@
 }
 
 // Number of Key bytes plus number of Val bytes.
-func (i *Item) NumBytes(o *Store) int {
-	return len(i.Key) + i.NumValBytes(o)
+func (i *Item) NumBytes(c *Collection) int {
+	return len(i.Key) + i.NumValBytes(c)
 }
 
-func (i *Item) NumValBytes(o *Store) int {
-	if o.callbacks.ItemValLength != nil {
-		return o.callbacks.ItemValLength(i)
+func (i *Item) NumValBytes(c *Collection) int {
+	if c.store.callbacks.ItemValLength != nil {
+		return c.store.callbacks.ItemValLength(c, i)
 	}
 	return len(i.Val)
 }
@@ -459,21 +468,21 @@
 	atomic.StorePointer(&i.item, unsafe.Pointer(src.Item()))
 }
 
-func (i *itemLoc) write(o *Store) (err error) {
+func (i *itemLoc) write(c *Collection) (err error) {
 	if i.Loc().isEmpty() {
 		iItem := i.Item()
 		if iItem == nil {
 			return errors.New("itemLoc.write with nil item")
 		}
-		if o.callbacks.BeforeItemWrite != nil {
-			iItem, err = o.callbacks.BeforeItemWrite(iItem)
+		if c.store.callbacks.BeforeItemWrite != nil {
+			iItem, err = c.store.callbacks.BeforeItemWrite(c, iItem)
 			if err != nil {
 				return err
 			}
 		}
-		offset := atomic.LoadInt64(&o.size)
+		offset := atomic.LoadInt64(&c.store.size)
 		hlength := 4 + 2 + 4 + 4 + len(iItem.Key)
-		vlength := iItem.NumValBytes(o)
+		vlength := iItem.NumValBytes(c)
 		ilength := hlength + vlength
 		b := make([]byte, hlength)
 		pos := 0
@@ -490,28 +499,29 @@
 			return fmt.Errorf("itemLoc.write() pos: %v didn't match hlength: %v",
 				pos, hlength)
 		}
-		if _, err := o.file.WriteAt(b, offset); err != nil {
+		if _, err := c.store.file.WriteAt(b, offset); err != nil {
 			return err
 		}
-		if o.callbacks.ItemValWrite != nil {
-			err := o.callbacks.ItemValWrite(iItem, o.file, offset+int64(pos))
+		if c.store.callbacks.ItemValWrite != nil {
+			err := c.store.callbacks.ItemValWrite(c, iItem, c.store.file,
+				offset+int64(pos))
 			if err != nil {
 				return err
 			}
 		} else {
-			_, err := o.file.WriteAt(iItem.Val, offset+int64(pos))
+			_, err := c.store.file.WriteAt(iItem.Val, offset+int64(pos))
 			if err != nil {
 				return err
 			}
 		}
-		atomic.StoreInt64(&o.size, offset+int64(ilength))
+		atomic.StoreInt64(&c.store.size, offset+int64(ilength))
 		atomic.StorePointer(&i.loc,
 			unsafe.Pointer(&ploc{Offset: offset, Length: uint32(ilength)}))
 	}
 	return nil
 }
 
-func (iloc *itemLoc) read(o *Store, withValue bool) (i *Item, err error) {
+func (iloc *itemLoc) read(c *Collection, withValue bool) (i *Item, err error) {
 	if iloc == nil {
 		return nil, nil
 	}
@@ -527,7 +537,7 @@
 				loc.Length, hdrLength)
 		}
 		b := make([]byte, hdrLength)
-		if _, err := o.file.ReadAt(b, loc.Offset); err != nil {
+		if _, err := c.store.file.ReadAt(b, loc.Offset); err != nil {
 			return nil, err
 		}
 		i = &Item{}
@@ -547,27 +557,27 @@
 			return nil, fmt.Errorf("read pos != hdrLength, %v != %v", pos, hdrLength)
 		}
 		i.Key = make([]byte, keyLength)
-		if _, err := o.file.ReadAt(i.Key,
+		if _, err := c.store.file.ReadAt(i.Key,
 			loc.Offset+int64(hdrLength)); err != nil {
 			return nil, err
 		}
 		if withValue {
-			if o.callbacks.ItemValRead != nil {
-				err := o.callbacks.ItemValRead(i, o.file,
+			if c.store.callbacks.ItemValRead != nil {
+				err := c.store.callbacks.ItemValRead(c, i, c.store.file,
 					loc.Offset+int64(hdrLength)+int64(keyLength), valLength)
 				if err != nil {
 					return nil, err
 				}
 			} else {
 				i.Val = make([]byte, valLength)
-				if _, err := o.file.ReadAt(i.Val,
+				if _, err := c.store.file.ReadAt(i.Val,
 					loc.Offset+int64(hdrLength)+int64(keyLength)); err != nil {
 					return nil, err
 				}
 			}
 		}
-		if o.callbacks.AfterItemRead != nil {
-			i, err = o.callbacks.AfterItemRead(i)
+		if c.store.callbacks.AfterItemRead != nil {
+			i, err = c.store.callbacks.AfterItemRead(c, i)
 			if err != nil {
 				return nil, err
 			}
@@ -625,7 +635,7 @@
 			return nil, err
 		}
 		i := &nNode.item
-		iItem, err := i.read(t.store, false)
+		iItem, err := i.read(t, false)
 		if err != nil {
 			return nil, err
 		}
@@ -639,7 +649,7 @@
 			n = &nNode.right
 		} else {
 			if withValue {
-				iItem, err = i.read(t.store, withValue)
+				iItem, err = i.read(t, withValue)
 				if err != nil {
 					return nil, err
 				}
@@ -677,7 +687,7 @@
 	}
 	root := atomic.LoadPointer(&t.root)
 	n := t.mkNode(nil, nil, nil,
-		1, uint64(len(item.Key))+uint64(item.NumValBytes(t.store)))
+		1, uint64(len(item.Key))+uint64(item.NumValBytes(t)))
 	n.item = itemLoc{item: unsafe.Pointer(&Item{
 		Key:       item.Key,
 		Val:       item.Val,
@@ -826,7 +836,7 @@
 // make these writes visible to the next file re-opening/re-loading.
 func (t *Collection) Write() (err error) {
 	root := (*nodeLoc)(atomic.LoadPointer(&t.root))
-	if err = t.store.flushItems(root); err != nil {
+	if err = t.flushItems(root); err != nil {
 		return err
 	}
 	if err = t.store.flushNodes(root); err != nil {
@@ -889,7 +899,7 @@
 	t.freeNodes = n
 }
 
-func (o *Store) flushItems(nloc *nodeLoc) (err error) {
+func (t *Collection) flushItems(nloc *nodeLoc) (err error) {
 	if nloc == nil || !nloc.Loc().isEmpty() {
 		return nil // Flush only unpersisted items of non-empty, unpersisted nodes.
 	}
@@ -897,13 +907,13 @@
 	if node == nil {
 		return nil
 	}
-	if err = o.flushItems(&node.left); err != nil {
+	if err = t.flushItems(&node.left); err != nil {
 		return err
 	}
-	if err = node.item.write(o); err != nil { // Write items in key order.
+	if err = node.item.write(t); err != nil { // Write items in key order.
 		return err
 	}
-	return o.flushItems(&node.right)
+	return t.flushItems(&node.right)
 }
 
 func (o *Store) flushNodes(nloc *nodeLoc) (err error) {
@@ -940,12 +950,12 @@
 		return this, false, nil
 	}
 	thisItemLoc := &thisNode.item
-	thisItem, err := thisItemLoc.read(o, false)
+	thisItem, err := thisItemLoc.read(t, false)
 	if err != nil {
 		return empty_nodeLoc, false, err
 	}
 	thatItemLoc := &thatNode.item
-	thatItem, err := thatItemLoc.read(o, false)
+	thatItem, err := thatItemLoc.read(t, false)
 	if err != nil {
 		return empty_nodeLoc, false, err
 	}
@@ -975,7 +985,7 @@
 		if middle.isEmpty() {
 			res = t.mkNodeLoc(t.mkNode(thisItemLoc, newLeft, newRight,
 				leftNum+rightNum+1,
-				leftBytes+rightBytes+uint64(thisItem.NumBytes(o))))
+				leftBytes+rightBytes+uint64(thisItem.NumBytes(t))))
 			if newLeftIsNew {
 				t.freeNodeLoc(newLeft)
 			}
@@ -988,13 +998,13 @@
 		if err != nil {
 			return empty_nodeLoc, false, err
 		}
-		middleItem, err := middleNode.item.read(o, false)
+		middleItem, err := middleNode.item.read(t, false)
 		if err != nil {
 			return empty_nodeLoc, false, err
 		}
 		res = t.mkNodeLoc(t.mkNode(&middleNode.item, newLeft, newRight,
 			leftNum+rightNum+1,
-			leftBytes+rightBytes+uint64(middleItem.NumBytes(o))))
+			leftBytes+rightBytes+uint64(middleItem.NumBytes(t))))
 		if newLeftIsNew {
 			t.freeNodeLoc(newLeft)
 		}
@@ -1028,7 +1038,7 @@
 	}
 	res = t.mkNodeLoc(t.mkNode(thatItemLoc, newLeft, newRight,
 		leftNum+rightNum+1,
-		leftBytes+rightBytes+uint64(thatItem.NumBytes(o))))
+		leftBytes+rightBytes+uint64(thatItem.NumBytes(t))))
 	if newLeftIsNew {
 		t.freeNodeLoc(newLeft)
 	}
@@ -1052,7 +1062,7 @@
 	}
 
 	nItemLoc := &nNode.item
-	nItem, err := nItemLoc.read(o, false)
+	nItem, err := nItemLoc.read(t, false)
 	if err != nil {
 		return empty_nodeLoc, empty_nodeLoc, empty_nodeLoc, false, false, err
 	}
@@ -1073,7 +1083,7 @@
 		}
 		newRight := t.mkNodeLoc(t.mkNode(nItemLoc, right, &nNode.right,
 			leftNum+rightNum+1,
-			leftBytes+rightBytes+uint64(nItem.NumBytes(o))))
+			leftBytes+rightBytes+uint64(nItem.NumBytes(t))))
 		if rightIsNew {
 			t.freeNodeLoc(right)
 		}
@@ -1090,7 +1100,7 @@
 	}
 	newLeft := t.mkNodeLoc(t.mkNode(nItemLoc, &nNode.left, left,
 		leftNum+rightNum+1,
-		leftBytes+rightBytes+uint64(nItem.NumBytes(o))))
+		leftBytes+rightBytes+uint64(nItem.NumBytes(t))))
 	if leftIsNew {
 		t.freeNodeLoc(left)
 	}
@@ -1115,12 +1125,12 @@
 		return this, nil
 	}
 	thisItemLoc := &thisNode.item
-	thisItem, err := thisItemLoc.read(o, false)
+	thisItem, err := thisItemLoc.read(t, false)
 	if err != nil {
 		return empty_nodeLoc, err
 	}
 	thatItemLoc := &thatNode.item
-	thatItem, err := thatItemLoc.read(o, false)
+	thatItem, err := thatItemLoc.read(t, false)
 	if err != nil {
 		return empty_nodeLoc, err
 	}
@@ -1135,7 +1145,7 @@
 		}
 		return t.mkNodeLoc(t.mkNode(thisItemLoc, &thisNode.left, newRight,
 			leftNum+rightNum+1,
-			leftBytes+rightBytes+uint64(thisItem.NumBytes(o)))), nil
+			leftBytes+rightBytes+uint64(thisItem.NumBytes(t)))), nil
 	}
 	newLeft, err := o.join(t, this, &thatNode.left)
 	if err != nil {
@@ -1147,7 +1157,7 @@
 	}
 	return t.mkNodeLoc(t.mkNode(thatItemLoc, newLeft, &thatNode.right,
 		leftNum+rightNum+1,
-		leftBytes+rightBytes+uint64(thatItem.NumBytes(o)))), nil
+		leftBytes+rightBytes+uint64(thatItem.NumBytes(t)))), nil
 }
 
 func (o *Store) walk(t *Collection, withValue bool, cfn func(*node) (*nodeLoc, bool)) (
@@ -1167,7 +1177,7 @@
 			return nil, err
 		}
 		if child.isEmpty() || childNode == nil {
-			i, err := nNode.item.read(o, withValue)
+			i, err := nNode.item.read(t, withValue)
 			if err != nil {
 				return nil, err
 			}
@@ -1189,7 +1199,7 @@
 		return true, nil
 	}
 	nItemLoc := &nNode.item
-	nItem, err := nItemLoc.read(o, false)
+	nItem, err := nItemLoc.read(t, false)
 	if err != nil {
 		return false, err
 	}
@@ -1200,7 +1210,7 @@
 		if err != nil || !keepGoing {
 			return false, err
 		}
-		nItem, err := nItemLoc.read(o, withValue)
+		nItem, err := nItemLoc.read(t, withValue)
 		if err != nil {
 			return false, err
 		}
diff --git a/store_test.go b/store_test.go
index b078d64..3fbdfee 100644
--- a/store_test.go
+++ b/store_test.go
@@ -207,8 +207,8 @@
 		t.Error("expected success on just perfect key length")
 	}
 	err = xx.SetItem(&Item{
-		Key: make([]byte, 0xffff),
-		Val: []byte{},
+		Key:      make([]byte, 0xffff),
+		Val:      []byte{},
 		Priority: -1})
 	if err == nil {
 		t.Error("expected error on -1 Priority")