fix warnings

bundle/manager.go

···
 }
 
 // loadBundleFromDisk loads a bundle from disk
-func (m *Manager) loadBundleFromDisk(ctx context.Context, bundleNumber int) (*Bundle, error) {
+func (m *Manager) loadBundleFromDisk(_ context.Context, bundleNumber int) (*Bundle, error) {
 	// Get metadata from index
 	meta, err := m.index.GetBundle(bundleNumber)
 	if err != nil {
···
 	// Find latest non-nullified location
 	var latestLoc *didindex.OpLocation
 	for i := range locations {
-		if locations[i].Nullified {
+		if locations[i].Nullified() {
 			continue
 		}
-		if latestLoc == nil ||
-			locations[i].Bundle > latestLoc.Bundle ||
-			(locations[i].Bundle == latestLoc.Bundle && locations[i].Position > latestLoc.Position) {
+		if latestLoc == nil || locations[i].IsAfter(*latestLoc) {
 			latestLoc = &locations[i]
 		}
 	}
···
 
 	// STEP 3: Load operation
 	opStart := time.Now()
-	op, err := m.LoadOperation(ctx, int(latestLoc.Bundle), int(latestLoc.Position))
+	op, err := m.LoadOperation(ctx, latestLoc.BundleInt(), latestLoc.PositionInt())
 	result.LoadOpTime = time.Since(opStart)
 
 	if err != nil {
 		return nil, fmt.Errorf("failed to load operation: %w", err)
 	}
 
-	result.BundleNumber = int(latestLoc.Bundle)
-	result.Position = int(latestLoc.Position)
+	result.BundleNumber = latestLoc.BundleInt()
+	result.Position = latestLoc.PositionInt()
 
 	// STEP 4: Resolve document
 	doc, err := plcclient.ResolveDIDDocument(did, []plcclient.PLCOperation{*op})

cmd/plcbundle/commands/detector.go

···
 `)
 }
 
-func detectorList(args []string) error {
+func detectorList(_ []string) error {
 	registry := detector.DefaultRegistry()
 	detectors := registry.List()
 

cmd/plcbundle/commands/did.go

···
 	return nil
 }
 
-func batchLookup(mgr BundleManager, dids []string, output *os.File, workers int) error {
+func batchLookup(mgr BundleManager, dids []string, output *os.File, _ int) error {
 	progress := ui.NewProgressBar(len(dids))
 	ctx := context.Background()
 
···
 	return nil
 }
 
-func batchResolve(mgr BundleManager, dids []string, output *os.File, workers int) error {
+func batchResolve(mgr BundleManager, dids []string, output *os.File, _ int) error {
 	progress := ui.NewProgressBar(len(dids))
 	ctx := context.Background()
 
···
 	return nil
 }
 
-func batchExport(mgr BundleManager, dids []string, output *os.File, workers int) error {
+func batchExport(mgr BundleManager, dids []string, output *os.File, _ int) error {
 	progress := ui.NewProgressBar(len(dids))
 	ctx := context.Background()
 

cmd/plcbundle/commands/export.go

···
 	}
 
 	if !*all && *bundles == "" {
-		return fmt.Errorf("usage: plcbundle export --bundles <number|range> [options]\n" +
-			"   or: plcbundle export --all [options]\n\n" +
-			"Examples:\n" +
-			"  plcbundle export --bundles 42\n" +
-			"  plcbundle export --bundles 1-100\n" +
-			"  plcbundle export --all\n" +
-			"  plcbundle export --all --count 50000\n" +
-			"  plcbundle export --bundles 42 | jq .")
+		fmt.Fprint(os.Stderr, `usage: plcbundle export --bundles <number|range> [options]
+   or: plcbundle export --all [options]
+
+Examples:
+  plcbundle export --bundles 42
+  plcbundle export --bundles 1-100
+  plcbundle export --all
+  plcbundle export --all --count 50000
+  plcbundle export --bundles 42 | jq .
+
+`)
+		return fmt.Errorf("missing required flag: --bundles or --all")
 	}
 
 	mgr, _, err := getManager(&ManagerOptions{Cmd: nil})

cmd/plcbundle/commands/log.go

···
 	// Display bundles
 	for i, meta := range displayBundles {
 		if opts.oneline {
-			displayBundleOneLine(w, meta, opts.showHashes, useColor, colorBundleNum, colorHash, colorDate, colorAge, colorSize, colorReset)
+			displayBundleOneLine(w, meta, opts.showHashes, colorBundleNum, colorHash, colorDate, colorAge, colorSize, colorReset)
 		} else {
-			displayBundleDetailed(w, meta, opts.showHashes, useColor, colorBundleNum, colorHash, colorDate, colorAge, colorSize, colorDim, colorReset)
+			displayBundleDetailed(w, meta, opts.showHashes, colorBundleNum, colorHash, colorDate, colorAge, colorSize, colorDim, colorReset)
 
 			// Add separator between bundles (except last)
 			if i < len(displayBundles)-1 {
···
 	// Summary footer
 	if !opts.oneline && len(displayBundles) > 0 {
 		fmt.Fprintf(w, "\n")
-		displayLogSummary(w, allBundles, displayBundles, opts.last, useColor, colorHeader, colorReset)
+		displayLogSummary(w, allBundles, displayBundles, opts.last, colorHeader, colorReset)
 	}
 }
 
-func displayBundleOneLine(w io.Writer, meta *bundleindex.BundleMetadata, showHashes bool, useColor bool, colorBundle, colorHash, colorDate, colorAge, colorSize, colorReset string) {
+func displayBundleOneLine(w io.Writer, meta *bundleindex.BundleMetadata, showHashes bool, colorBundle, colorHash, colorDate, colorAge, colorSize, colorReset string) {
 	age := time.Since(meta.EndTime)
 	ageStr := formatDurationShort(age)
 
···
 		colorSize, formatBytes(meta.CompressedSize), colorReset)
 }
 
-func displayBundleDetailed(w io.Writer, meta *bundleindex.BundleMetadata, showHashes bool, useColor bool, colorBundle, colorHash, colorDate, colorAge, colorSize, colorDim, colorReset string) {
+func displayBundleDetailed(w io.Writer, meta *bundleindex.BundleMetadata, showHashes bool, colorBundle, colorHash, colorDate, colorAge, colorSize, colorDim, colorReset string) {
 	fmt.Fprintf(w, "%sBundle %06d%s\n", colorBundle, meta.BundleNumber, colorReset)
 
 	// Timestamp and age
···
 	}
 }
 
-func displayLogSummary(w io.Writer, allBundles, displayedBundles []*bundleindex.BundleMetadata, limit int, useColor bool, colorHeader, colorReset string) {
+func displayLogSummary(w io.Writer, allBundles, displayedBundles []*bundleindex.BundleMetadata, limit int, colorHeader, colorReset string) {
 	first := displayedBundles[0]
 	last := displayedBundles[len(displayedBundles)-1]
 

cmd/plcbundle/commands/mempool.go

···
 	return cmd
 }
 
-func mempoolStatus(cmd *cobra.Command, args []string) error {
+func mempoolStatus(cmd *cobra.Command, _ []string) error {
 	verbose, _ := cmd.Flags().GetBool("verbose")
 	if cmd.Parent() != nil {
 		// Called as subcommand, check parent's verbose flag

cmd/plcbundle/commands/rollback.go

···
 		fmt.Printf("   plcbundle index build\n\n")
 	}
 }
-
-// Validation helpers
-
-// validateRollbackSafety performs additional safety checks
-func validateRollbackSafety(mgr BundleManager, plan *rollbackPlan) error {
-	// Check for chain integrity issues
-	if len(plan.toKeep) > 1 {
-		// Verify the target bundle exists and has valid hash
-		lastKeep := plan.toKeep[len(plan.toKeep)-1]
-		if lastKeep.Hash == "" {
-			return fmt.Errorf("target bundle %06d has no chain hash - may be corrupted",
-				lastKeep.BundleNumber)
-		}
-	}
-
-	return nil
-}

cmd/plcbundle/commands/stream.go

···
 }
 
 type streamLogger struct {
-	quiet   bool
-	verbose bool
+	quiet bool
 }
 
 func (l *streamLogger) Printf(format string, v ...interface{}) {

internal/didindex/builder.go

···
 }
 
 // add adds a location to the shard
-func (sb *ShardBuilder) add(identifier string, bundle uint16, position uint16, nullified bool) {
+func (sb *ShardBuilder) add(identifier string, loc OpLocation) {
 	sb.mu.Lock()
 	defer sb.mu.Unlock()
 
-	sb.entries[identifier] = append(sb.entries[identifier], OpLocation{
-		Bundle:    bundle,
-		Position:  position,
-		Nullified: nullified,
-	})
+	sb.entries[identifier] = append(sb.entries[identifier], loc)
+}
+
+// updateAndSaveConfig updates config with new values and saves atomically
+func (dim *Manager) updateAndSaveConfig(totalDIDs int64, lastBundle int) error {
+	dim.config.TotalDIDs = totalDIDs
+	dim.config.LastBundle = lastBundle
+	dim.config.Version = DIDINDEX_VERSION
+	dim.config.Format = "binary_v4"
+	dim.config.UpdatedAt = time.Now().UTC()
+
+	return dim.saveIndexConfig()
 }
 
 // BuildIndexFromScratch builds index with controlled memory usage
···
 
 			shardNum := dim.calculateShard(identifier)
 
-			// Write entry: [24 bytes ID][2 bytes bundle][2 bytes pos][1 byte nullified]
-			entry := make([]byte, 29)
+			// Write entry: [24 bytes ID][4 bytes packed OpLocation]
+			entry := make([]byte, 28)
 			copy(entry[0:24], identifier)
-			binary.LittleEndian.PutUint16(entry[24:26], uint16(meta.BundleNumber))
-			binary.LittleEndian.PutUint16(entry[26:28], uint16(pos))
 
-			// Store nullified flag
-			if op.IsNullified() {
-				entry[28] = 1
-			} else {
-				entry[28] = 0
-			}
+			// Create packed OpLocation (includes nullified bit)
+			loc := NewOpLocation(uint16(meta.BundleNumber), uint16(pos), op.IsNullified())
+			binary.LittleEndian.PutUint32(entry[24:28], uint32(loc))
 
 			if _, err := tempShards[shardNum].Write(entry); err != nil {
 				dim.logger.Printf("Warning: failed to write to temp shard %02x: %v", shardNum, err)
···
 		totalDIDs += count
 	}
 
-	dim.config.TotalDIDs = totalDIDs
-	dim.config.LastBundle = bundles[len(bundles)-1].BundleNumber
-
-	if err := dim.saveIndexConfig(); err != nil {
+	if err := dim.updateAndSaveConfig(totalDIDs, bundles[len(bundles)-1].BundleNumber); err != nil {
 		return fmt.Errorf("failed to save config: %w", err)
 	}
 
···
 		return 0, nil
 	}
 
-	// Parse entries (29 bytes each)
-	entryCount := len(data) / 29
-	if len(data)%29 != 0 {
-		return 0, fmt.Errorf("corrupted temp shard: size not multiple of 29")
+	// Parse entries (28 bytes each)
+	entryCount := len(data) / 28
+	if len(data)%28 != 0 {
+		return 0, fmt.Errorf("corrupted temp shard: size not multiple of 28")
 	}
 
 	type tempEntry struct {
 		identifier string
-		bundle     uint16
-		position   uint16
-		nullified  bool
+		location   OpLocation // ← Single packed value
 	}
 
 	entries := make([]tempEntry, entryCount)
 	for i := 0; i < entryCount; i++ {
-		offset := i * 29
+		offset := i * 28 // ← 28 bytes
 		entries[i] = tempEntry{
 			identifier: string(data[offset : offset+24]),
-			bundle:     binary.LittleEndian.Uint16(data[offset+24 : offset+26]),
-			position:   binary.LittleEndian.Uint16(data[offset+26 : offset+28]),
-			nullified:  data[offset+28] != 0,
+			location:   OpLocation(binary.LittleEndian.Uint32(data[offset+24 : offset+28])),
 		}
 	}
 
···
 	// Group by DID
 	builder := newShardBuilder()
 	for _, entry := range entries {
-		builder.add(entry.identifier, entry.bundle, entry.position, entry.nullified)
+		builder.add(entry.identifier, entry.location)
 	}
 
 	// Free entries
···
 			shardOps[shardNum] = make(map[string][]OpLocation)
 		}
 
-		shardOps[shardNum][identifier] = append(shardOps[shardNum][identifier], OpLocation{
-			Bundle:    uint16(bundle.BundleNumber),
-			Position:  uint16(pos),
-			Nullified: op.IsNullified(),
-		})
+		loc := NewOpLocation(uint16(bundle.BundleNumber), uint16(pos), op.IsNullified())
+		shardOps[shardNum][identifier] = append(shardOps[shardNum][identifier], loc)
 	}
 
 	groupDuration := time.Since(groupStart)
···
 	// STEP 4: Update config
 	configStart := time.Now()
 
-	dim.config.TotalDIDs += deltaCount
-	dim.config.LastBundle = bundle.BundleNumber
-
-	if err := dim.saveIndexConfig(); err != nil {
+	newTotal := dim.config.TotalDIDs + deltaCount
+	if err := dim.updateAndSaveConfig(newTotal, bundle.BundleNumber); err != nil {
 		return fmt.Errorf("failed to save config: %w", err)
 	}
 

internal/didindex/lookup.go

···
 	// Filter nullified
 	var validLocations []OpLocation
 	for _, loc := range locations {
-		if !loc.Nullified {
+		if !loc.Nullified() {
 			validLocations = append(validLocations, loc)
 		}
 	}
···
 
 	if len(validLocations) == 1 {
 		loc := validLocations[0]
-		op, err := provider.LoadOperation(ctx, int(loc.Bundle), int(loc.Position))
+		op, err := provider.LoadOperation(ctx, loc.BundleInt(), loc.PositionInt())
 		if err != nil {
 			return nil, err
 		}
···
 	// For multiple operations: group by bundle to minimize bundle loads
 	bundleMap := make(map[uint16][]uint16)
 	for _, loc := range validLocations {
-		bundleMap[loc.Bundle] = append(bundleMap[loc.Bundle], loc.Position)
+		bundleMap[loc.Bundle()] = append(bundleMap[loc.Bundle()], loc.Position())
 	}
 
 	if dim.verbose {
···
 	// Group by bundle
 	bundleMap := make(map[uint16][]OpLocation)
 	for _, loc := range locations {
-		bundleMap[loc.Bundle] = append(bundleMap[loc.Bundle], loc)
+		bundleMap[loc.Bundle()] = append(bundleMap[loc.Bundle()], loc)
 	}
 
 	if dim.verbose {
···
 		}
 
 		for _, loc := range locs {
-			if int(loc.Position) >= len(bundle.Operations) {
+			if loc.PositionInt() >= len(bundle.Operations) {
 				continue
 			}
 
-			op := bundle.Operations[loc.Position]
+			op := bundle.Operations[loc.Position()]
 			results = append(results, OpLocationWithOperation{
 				Operation: op,
-				Bundle:    int(loc.Bundle),
-				Position:  int(loc.Position),
+				Bundle:    loc.BundleInt(),
+				Position:  loc.PositionInt(),
 			})
 		}
 	}
···
 	// Find latest non-nullified location
 	var latestLoc *OpLocation
 	for i := range locations {
-		if locations[i].Nullified {
+		if locations[i].Nullified() {
 			continue
 		}
 
 		if latestLoc == nil {
 			latestLoc = &locations[i]
 		} else {
-			if locations[i].Bundle > latestLoc.Bundle ||
-				(locations[i].Bundle == latestLoc.Bundle && locations[i].Position > latestLoc.Position) {
+			if locations[i].Bundle() > latestLoc.Bundle() ||
+				(locations[i].Bundle() == latestLoc.Bundle() && locations[i].Position() > latestLoc.Position()) {
 				latestLoc = &locations[i]
 			}
 		}
···
 	}
 
 	// Load ONLY the specific operation (efficient!)
-	return provider.LoadOperation(ctx, int(latestLoc.Bundle), int(latestLoc.Position))
+	return provider.LoadOperation(ctx, latestLoc.BundleInt(), latestLoc.PositionInt())
 }

internal/didindex/manager.go

···
 	config, _ := loadIndexConfig(configPath)
 	if config == nil {
 		config = &Config{
-			Version:    DIDINDEX_VERSION,
-			Format:     "binary_v1",
+			Version:    DIDINDEX_VERSION, // Will be 4
+			Format:     "binary_v4",      // Update format name
 			ShardCount: DID_SHARD_COUNT,
 			UpdatedAt:  time.Now().UTC(),
 		}
+	} else if config.Version < DIDINDEX_VERSION {
+		// Auto-trigger rebuild on version mismatch
+		logger.Printf("DID index version outdated (v%d, need v%d) - rebuild required",
+			config.Version, DIDINDEX_VERSION)
 	}
 
 	return &Manager{
···
 		config:            config,
 		logger:            logger,
 	}
-}
-
-// Add helper to ensure directories when actually writing
-func (dim *Manager) ensureDirectories() error {
-	return os.MkdirAll(dim.shardDir, 0755)
 }
 
 // Close unmaps all shards and cleans up
···
 
 // searchShard performs optimized binary search using prefix index
 func (dim *Manager) searchShard(shard *mmapShard, identifier string) []OpLocation {
-	if shard.data == nil || len(shard.data) < 1056 {
+	if len(shard.data) < 1056 {
 		return nil
 	}
 
···
 	// Read locations
 	locations := make([]OpLocation, count)
 	for i := 0; i < int(count); i++ {
-		if offset+5 > len(data) {
+		if offset+4 > len(data) { // ← 4 bytes now
 			return locations[:i]
 		}
 
-		bundle := binary.LittleEndian.Uint16(data[offset : offset+2])
-		position := binary.LittleEndian.Uint16(data[offset+2 : offset+4])
-		nullified := data[offset+4] != 0
+		// Read packed uint32
+		packed := binary.LittleEndian.Uint32(data[offset : offset+4])
+		locations[i] = OpLocation(packed)
 
-		locations[i] = OpLocation{
-			Bundle:    bundle,
-			Position:  position,
-			Nullified: nullified,
-		}
-
-		offset += 5
+		offset += 4 // ← 4 bytes
 	}
 
 	return locations
···
 	for i, id := range identifiers {
 		offsetTable[i] = uint32(currentOffset)
 		locations := builder.entries[id]
-		entrySize := DID_IDENTIFIER_LEN + 2 + (len(locations) * 5)
+		entrySize := DID_IDENTIFIER_LEN + 2 + (len(locations) * 4) // ← 4 bytes
 		currentOffset += entrySize
 	}
 
···
 		offset += 2
 
 		for _, loc := range locations {
-			binary.LittleEndian.PutUint16(buf[offset:offset+2], loc.Bundle)
-			binary.LittleEndian.PutUint16(buf[offset+2:offset+4], loc.Position)
-
-			if loc.Nullified {
-				buf[offset+4] = 1
-			} else {
-				buf[offset+4] = 0
-			}
-
-			offset += 5
+			// Write packed uint32 (global position + nullified bit)
+			binary.LittleEndian.PutUint32(buf[offset:offset+4], uint32(loc))
+			offset += 4 // ← 4 bytes per location
 		}
 	}
 
···
 
 	entryCount := binary.LittleEndian.Uint32(data[9:13])
 
-	var offsetTableStart int
-	offsetTableStart = 1056
+	offsetTableStart := 1056
 
 	// Start reading entries after offset table
 	offset := offsetTableStart + (int(entryCount) * 4)
···
 
 		// Read locations
 		locations := make([]OpLocation, locCount)
+
+		// Check version to determine format
+		version := binary.LittleEndian.Uint32(data[4:8])
+
 		for j := 0; j < int(locCount); j++ {
-			if offset+5 > len(data) {
-				break
-			}
+			if version >= 4 {
+				// New format: 4-byte packed uint32
+				if offset+4 > len(data) {
+					break
+				}
+				packed := binary.LittleEndian.Uint32(data[offset : offset+4])
+				locations[j] = OpLocation(packed)
+				offset += 4
+			} else {
+				// Old format: 5-byte separate fields (for migration)
+				if offset+5 > len(data) {
+					break
+				}
+				bundle := binary.LittleEndian.Uint16(data[offset : offset+2])
+				position := binary.LittleEndian.Uint16(data[offset+2 : offset+4])
+				nullified := data[offset+4] != 0
 
-			locations[j] = OpLocation{
-				Bundle:    binary.LittleEndian.Uint16(data[offset : offset+2]),
-				Position:  binary.LittleEndian.Uint16(data[offset+2 : offset+4]),
-				Nullified: data[offset+4] != 0,
+				// Convert to new format
+				locations[j] = NewOpLocation(bundle, position, nullified)
+				offset += 5
 			}
-			offset += 5
 		}
 
 		builder.entries[identifier] = locations

internal/didindex/manager_test.go

···
+package didindex_test
+
+import (
+	"testing"
+
+	"tangled.org/atscan.net/plcbundle/internal/didindex"
+)
+
+func TestOpLocationPacking(t *testing.T) {
+	tests := []struct {
+		bundle    uint16
+		position  uint16
+		nullified bool
+	}{
+		{1, 0, false},
+		{1, 9999, false},
+		{100, 5000, true},
+		{65535, 9999, true}, // Max values
+	}
+
+	for _, tt := range tests {
+		loc := didindex.NewOpLocation(tt.bundle, tt.position, tt.nullified)
+
+		// Test unpacking
+		if loc.Bundle() != tt.bundle {
+			t.Errorf("Bundle mismatch: got %d, want %d", loc.Bundle(), tt.bundle)
+		}
+		if loc.Position() != tt.position {
+			t.Errorf("Position mismatch: got %d, want %d", loc.Position(), tt.position)
+		}
+		if loc.Nullified() != tt.nullified {
+			t.Errorf("Nullified mismatch: got %v, want %v", loc.Nullified(), tt.nullified)
+		}
+
+		// Test global position
+		expectedGlobal := uint32(tt.bundle)*10000 + uint32(tt.position)
+		if loc.GlobalPosition() != expectedGlobal {
+			t.Errorf("Global position mismatch: got %d, want %d",
+				loc.GlobalPosition(), expectedGlobal)
+		}
+	}
+}
+
+func TestOpLocationComparison(t *testing.T) {
+	loc1 := didindex.NewOpLocation(100, 50, false) // 1,000,050
+	loc2 := didindex.NewOpLocation(100, 51, false) // 1,000,051
+	loc3 := didindex.NewOpLocation(200, 30, false) // 2,000,030
+
+	if !loc1.Less(loc2) {
+		t.Error("Expected loc1 < loc2")
+	}
+	if !loc2.Less(loc3) {
+		t.Error("Expected loc2 < loc3")
+	}
+	if loc3.Less(loc1) {
+		t.Error("Expected loc3 > loc1")
+	}
+}

internal/didindex/types.go

···
 
 	// Binary format constants
 	DIDINDEX_MAGIC   = "PLCD"
-	DIDINDEX_VERSION = 3
+	DIDINDEX_VERSION = 4
+
+	// Format sizes
+	LOCATION_SIZE_V3 = 5 // Old: 2+2+1
+	LOCATION_SIZE_V4 = 4 // New: packed uint32
 
 	BUILD_BATCH_SIZE = 100 // Process 100 bundles at a time
 
···
 	LastBundle int       `json:"last_bundle"`
 }
 
-// OpLocation represents exact location of an operation
-type OpLocation struct {
-	Bundle    uint16
-	Position  uint16
-	Nullified bool
-}
-
 // ShardBuilder accumulates DID positions for a shard
 type ShardBuilder struct {
 	entries map[string][]OpLocation
 	mu      sync.Mutex
 }
 
+// OpLocation represents exact location of an operation
+type OpLocation uint32
+
 // OpLocationWithOperation contains an operation with its bundle/position
 type OpLocationWithOperation struct {
 	Operation plcclient.PLCOperation
 	Bundle    int
 	Position  int
 }
+
+func NewOpLocation(bundle, position uint16, nullified bool) OpLocation {
+	globalPos := uint32(bundle)*10000 + uint32(position)
+	loc := globalPos << 1
+	if nullified {
+		loc |= 1
+	}
+	return OpLocation(loc)
+}
+
+// Getters
+func (loc OpLocation) GlobalPosition() uint32 {
+	return uint32(loc) >> 1
+}
+
+func (loc OpLocation) Bundle() uint16 {
+	return uint16(loc.GlobalPosition() / 10000)
+}
+
+func (loc OpLocation) Position() uint16 {
+	return uint16(loc.GlobalPosition() % 10000)
+}
+
+func (loc OpLocation) Nullified() bool {
+	return (loc & 1) == 1
+}
+
+func (loc OpLocation) IsAfter(other OpLocation) bool {
+	// Compare global positions directly
+	return loc.GlobalPosition() > other.GlobalPosition()
+}
+
+func (loc OpLocation) IsBefore(other OpLocation) bool {
+	return loc.GlobalPosition() < other.GlobalPosition()
+}
+
+func (loc OpLocation) Equals(other OpLocation) bool {
+	// Compare entire packed value (including nullified bit)
+	return loc == other
+}
+
+func (loc OpLocation) PositionEquals(other OpLocation) bool {
+	// Compare only position (ignore nullified bit)
+	return loc.GlobalPosition() == other.GlobalPosition()
+}
+
+// Convenience conversions
+func (loc OpLocation) BundleInt() int {
+	return int(loc.Bundle())
+}
+
+func (loc OpLocation) PositionInt() int {
+	return int(loc.Position())
+}
+
+// For sorting/comparison
+func (loc OpLocation) Less(other OpLocation) bool {
+	return loc.GlobalPosition() < other.GlobalPosition()
+}