diff --git a/src/radbin/radbin.c b/src/radbin/radbin.c
index 132e821f..c54468bb 100644
--- a/src/radbin/radbin.c
+++ b/src/radbin/radbin.c
@@ -755,7 +755,7 @@ rb_thread_entry_point(void *p)
       RDIM_BakeResults bake_results = {0};
       if(convert_done) ProfScope("bake")
       {
-        bake_results = rdim2_bake(arena, &bake_params);
+        bake_results = rdim_bake(arena, &bake_params);
       }
       
       //- rjf: convert done => generate output
diff --git a/src/rdi_from_pdb/rdi_from_pdb.c b/src/rdi_from_pdb/rdi_from_pdb.c
index a42616c5..8f4a88f6 100644
--- a/src/rdi_from_pdb/rdi_from_pdb.c
+++ b/src/rdi_from_pdb/rdi_from_pdb.c
@@ -315,7 +315,7 @@ p2r_reg_code_from_arch_encoded_fp_reg(RDI_Arch arch, CV_EncodedFramePtrReg encod
 }
 
 internal RDIM_LocationInfo
-p2r2_location_info_from_addr_reg_off(Arena *arena, RDI_Arch arch, RDI_RegCode reg_code, U32 reg_byte_size, U32 reg_byte_pos, S64 offset, B32 extra_indirection)
+p2r_location_info_from_addr_reg_off(Arena *arena, RDI_Arch arch, RDI_RegCode reg_code, U32 reg_byte_size, U32 reg_byte_pos, S64 offset, B32 extra_indirection)
 {
   RDIM_LocationInfo result = {0};
   if(0 <= offset && offset <= (S64)max_U16)
@@ -352,7 +352,7 @@ p2r2_location_info_from_addr_reg_off(Arena *arena, RDI_Arch arch, RDI_RegCode re
 }
 
 internal void
-p2r2_local_push_location_cases_over_lvar_addr_range(Arena *arena, RDIM_ScopeChunkList *scopes, RDIM_Local *local, RDIM_Location *loc, CV_LvarAddrRange *range, COFF_SectionHeader *section, CV_LvarAddrGap *gaps, U64 gap_count)
+p2r_local_push_location_cases_over_lvar_addr_range(Arena *arena, RDIM_ScopeChunkList *scopes, RDIM_Local *local, RDIM_Location *loc, CV_LvarAddrRange *range, COFF_SectionHeader *section, CV_LvarAddrGap *gaps, U64 gap_count)
 {
   //- rjf: extract range info
   U64 voff_first = 0;
@@ -399,14 +399,14 @@ p2r_convert(Arena *arena, P2R_ConvertParams *params)
     // rjf: setup output buckets
     if(lane_idx() == 0)
     {
-      p2r2_shared = push_array(arena, P2R2_Shared, 1);
-      p2r2_shared->msf_raw_stream_table = msf_raw_stream_table_from_data(arena, params->input_pdb_data);
-      p2r2_shared->msf = push_array(arena, MSF_Parsed, 1);
-      p2r2_shared->msf->page_size    = p2r2_shared->msf_raw_stream_table->page_size;
-      p2r2_shared->msf->page_count   = p2r2_shared->msf_raw_stream_table->total_page_count;
-      p2r2_shared->msf->stream_count = p2r2_shared->msf_raw_stream_table->stream_count;
-      p2r2_shared->msf->streams      = push_array(arena, String8, p2r2_shared->msf->stream_count);
-      p2r2_shared->msf_stream_lane_counter = 0;
+      p2r_shared = push_array(arena, P2R_Shared, 1);
+      p2r_shared->msf_raw_stream_table = msf_raw_stream_table_from_data(arena, params->input_pdb_data);
+      p2r_shared->msf = push_array(arena, MSF_Parsed, 1);
+      p2r_shared->msf->page_size    = p2r_shared->msf_raw_stream_table->page_size;
+      p2r_shared->msf->page_count   = p2r_shared->msf_raw_stream_table->total_page_count;
+      p2r_shared->msf->stream_count = p2r_shared->msf_raw_stream_table->stream_count;
+      p2r_shared->msf->streams      = push_array(arena, String8, p2r_shared->msf->stream_count);
+      p2r_shared->msf_stream_lane_counter = 0;
     }
     lane_sync();
     
@@ -414,18 +414,18 @@ p2r_convert(Arena *arena, P2R_ConvertParams *params)
     {
       for(;;)
       {
-        U64 stream_num = ins_atomic_u64_inc_eval(&p2r2_shared->msf_stream_lane_counter);
-        if(stream_num < 1 || p2r2_shared->msf->stream_count < stream_num)
+        U64 stream_num = ins_atomic_u64_inc_eval(&p2r_shared->msf_stream_lane_counter);
+        if(stream_num < 1 || p2r_shared->msf->stream_count < stream_num)
         {
           break;
         }
         U64 stream_idx = stream_num-1;
-        p2r2_shared->msf->streams[stream_idx] = msf_data_from_stream_number(arena, params->input_pdb_data, p2r2_shared->msf_raw_stream_table, stream_idx);
+        p2r_shared->msf->streams[stream_idx] = msf_data_from_stream_number(arena, params->input_pdb_data, p2r_shared->msf_raw_stream_table, stream_idx);
       }
     }
   }
   lane_sync();
-  MSF_Parsed *msf = p2r2_shared->msf;
+  MSF_Parsed *msf = p2r_shared->msf;
   
   //////////////////////////////////////////////////////////////
   //- rjf: do top-level MSF/PDB extraction
@@ -435,20 +435,20 @@ p2r_convert(Arena *arena, P2R_ConvertParams *params)
     ProfScope("parse PDB info")
     {
       String8 info_data = msf_data_from_stream(msf, PDB_FixedStream_Info);
-      p2r2_shared->pdb_info = pdb_info_from_data(arena, info_data);
-      if(p2r2_shared->pdb_info->features & PDB_FeatureFlag_MINIMAL_DBG_INFO)
+      p2r_shared->pdb_info = pdb_info_from_data(arena, info_data);
+      if(p2r_shared->pdb_info->features & PDB_FeatureFlag_MINIMAL_DBG_INFO)
       {
         log_user_error(str8_lit("PDB was linked with /DEBUG:FASTLINK; partial debug info is not supported. Please relink using /DEBUG:FULL."));
       }
     }
     ProfScope("parse named streams table")
     {
-      p2r2_shared->named_streams = pdb_named_stream_table_from_info(arena, p2r2_shared->pdb_info);
+      p2r_shared->named_streams = pdb_named_stream_table_from_info(arena, p2r_shared->pdb_info);
     }
   }
   lane_sync();
-  PDB_Info *pdb_info = p2r2_shared->pdb_info;
-  PDB_NamedStreamTable *named_streams = p2r2_shared->named_streams;
+  PDB_Info *pdb_info = p2r_shared->pdb_info;
+  PDB_NamedStreamTable *named_streams = p2r_shared->named_streams;
   
   //////////////////////////////////////////////////////////////
   //- rjf: parse PDB strtbl & top-level streams
@@ -459,31 +459,31 @@ p2r_convert(Arena *arena, P2R_ConvertParams *params)
     {
       MSF_StreamNumber strtbl_sn = named_streams->sn[PDB_NamedStream_StringTable];
       String8 strtbl_data = msf_data_from_stream(msf, strtbl_sn);
-      p2r2_shared->strtbl = pdb_strtbl_from_data(arena, strtbl_data);
-      p2r2_shared->raw_strtbl = str8_substr(strtbl_data, rng_1u64(p2r2_shared->strtbl->strblock_min, p2r2_shared->strtbl->strblock_max));
+      p2r_shared->strtbl = pdb_strtbl_from_data(arena, strtbl_data);
+      p2r_shared->raw_strtbl = str8_substr(strtbl_data, rng_1u64(p2r_shared->strtbl->strblock_min, p2r_shared->strtbl->strblock_max));
     }
     if(lane_idx() == lane_from_task_idx(1)) ProfScope("parse DBI")
     {
       String8 dbi_data = msf_data_from_stream(msf, PDB_FixedStream_Dbi);
-      p2r2_shared->dbi = pdb_dbi_from_data(arena, dbi_data);
+      p2r_shared->dbi = pdb_dbi_from_data(arena, dbi_data);
     }
     if(lane_idx() == lane_from_task_idx(2)) ProfScope("parse TPI")
     {
       String8 tpi_data = msf_data_from_stream(msf, PDB_FixedStream_Tpi);
-      p2r2_shared->tpi = pdb_tpi_from_data(arena, tpi_data);
+      p2r_shared->tpi = pdb_tpi_from_data(arena, tpi_data);
     }
     if(lane_idx() == lane_from_task_idx(3)) ProfScope("parse IPI")
     {
       String8 ipi_data = msf_data_from_stream(msf, PDB_FixedStream_Ipi);
-      p2r2_shared->ipi = pdb_tpi_from_data(arena, ipi_data);
+      p2r_shared->ipi = pdb_tpi_from_data(arena, ipi_data);
     }
   }
   lane_sync();
-  PDB_Strtbl *strtbl = p2r2_shared->strtbl;
-  String8 raw_strtbl = p2r2_shared->raw_strtbl;
-  PDB_DbiParsed *dbi = p2r2_shared->dbi;
-  PDB_TpiParsed *tpi = p2r2_shared->tpi;
-  PDB_TpiParsed *ipi = p2r2_shared->ipi;
+  PDB_Strtbl *strtbl = p2r_shared->strtbl;
+  String8 raw_strtbl = p2r_shared->raw_strtbl;
+  PDB_DbiParsed *dbi = p2r_shared->dbi;
+  PDB_TpiParsed *tpi = p2r_shared->tpi;
+  PDB_TpiParsed *ipi = p2r_shared->ipi;
   
   //////////////////////////////////////////////////////////////
   //- rjf: unpack DBI
@@ -494,24 +494,24 @@ p2r_convert(Arena *arena, P2R_ConvertParams *params)
     {
       MSF_StreamNumber section_stream = dbi->dbg_streams[PDB_DbiStream_SECTION_HEADER];
       String8 section_data = msf_data_from_stream(msf, section_stream);
-      p2r2_shared->coff_sections = pdb_coff_section_array_from_data(arena, section_data);
+      p2r_shared->coff_sections = pdb_coff_section_array_from_data(arena, section_data);
     }
     if(lane_idx() == lane_from_task_idx(1)) ProfScope("parse GSI")
     {
       String8 gsi_data = msf_data_from_stream(msf, dbi->gsi_sn);
-      p2r2_shared->gsi = pdb_gsi_from_data(arena, gsi_data);
+      p2r_shared->gsi = pdb_gsi_from_data(arena, gsi_data);
     }
     if(lane_idx() == lane_from_task_idx(2)) ProfScope("parse GSI part of PSI")
     {
       String8 psi_data = msf_data_from_stream(msf, dbi->psi_sn);
       String8 psi_data_gsi_part = str8_range(psi_data.str + sizeof(PDB_PsiHeader), psi_data.str + psi_data.size);
-      p2r2_shared->psi_gsi_part = pdb_gsi_from_data(arena, psi_data_gsi_part);
+      p2r_shared->psi_gsi_part = pdb_gsi_from_data(arena, psi_data_gsi_part);
     }
   }
   lane_sync();
-  COFF_SectionHeaderArray coff_sections = p2r2_shared->coff_sections;
-  PDB_GsiParsed *gsi = p2r2_shared->gsi;
-  PDB_GsiParsed *psi_gsi_part = p2r2_shared->psi_gsi_part;
+  COFF_SectionHeaderArray coff_sections = p2r_shared->coff_sections;
+  PDB_GsiParsed *gsi = p2r_shared->gsi;
+  PDB_GsiParsed *psi_gsi_part = p2r_shared->psi_gsi_part;
   
   //////////////////////////////////////////////////////////////
   //- rjf: hash EXE, parse TPI/IPI hash/leaf & global symbol stream & comp units
@@ -520,68 +520,68 @@ p2r_convert(Arena *arena, P2R_ConvertParams *params)
   {
     if(lane_idx() == lane_from_task_idx(0)) ProfScope("hash EXE")
     {
-      p2r2_shared->exe_hash = rdi_hash(params->input_exe_data.str, params->input_exe_data.size);
+      p2r_shared->exe_hash = rdi_hash(params->input_exe_data.str, params->input_exe_data.size);
     }
     if(lane_idx() == lane_from_task_idx(1)) ProfScope("parse TPI hash")
     {
       String8 hash_data = msf_data_from_stream(msf, tpi->hash_sn);
       String8 aux_data  = msf_data_from_stream(msf, tpi->hash_sn_aux);
-      p2r2_shared->tpi_hash = pdb_tpi_hash_from_data(arena, strtbl, tpi, hash_data, aux_data);
+      p2r_shared->tpi_hash = pdb_tpi_hash_from_data(arena, strtbl, tpi, hash_data, aux_data);
     }
     if(lane_idx() == lane_from_task_idx(2)) ProfScope("parse TPI leaf")
     {
       String8 leaf_data = pdb_leaf_data_from_tpi(tpi);
-      p2r2_shared->tpi_leaf = cv_leaf_from_data(arena, leaf_data, tpi->itype_first);
+      p2r_shared->tpi_leaf = cv_leaf_from_data(arena, leaf_data, tpi->itype_first);
     }
     if(lane_idx() == lane_from_task_idx(3)) ProfScope("parse IPI hash")
     {
       String8 hash_data = msf_data_from_stream(msf, ipi->hash_sn);
       String8 aux_data  = msf_data_from_stream(msf, ipi->hash_sn_aux);
-      p2r2_shared->ipi_hash = pdb_tpi_hash_from_data(arena, strtbl, ipi, hash_data, aux_data);
+      p2r_shared->ipi_hash = pdb_tpi_hash_from_data(arena, strtbl, ipi, hash_data, aux_data);
     }
     if(lane_idx() == lane_from_task_idx(4)) ProfScope("parse IPI leaf")
     {
       String8 leaf_data = pdb_leaf_data_from_tpi(ipi);
-      p2r2_shared->ipi_leaf = cv_leaf_from_data(arena, leaf_data, ipi->itype_first);
+      p2r_shared->ipi_leaf = cv_leaf_from_data(arena, leaf_data, ipi->itype_first);
     }
     if(lane_idx() == lane_from_task_idx(5)) ProfScope("parse compilation units")
     {
       String8 comp_units_data = pdb_data_from_dbi_range(dbi, PDB_DbiRange_ModuleInfo);
-      p2r2_shared->comp_units = pdb_comp_unit_array_from_data(arena, comp_units_data);
+      p2r_shared->comp_units = pdb_comp_unit_array_from_data(arena, comp_units_data);
     }
     if(lane_idx() == lane_from_task_idx(6)) ProfScope("parse compilation unit contributions")
     {
       String8 contribs_data = pdb_data_from_dbi_range(dbi, PDB_DbiRange_SecCon);
-      p2r2_shared->comp_unit_contributions = pdb_comp_unit_contribution_array_from_data(arena, contribs_data, coff_sections);
+      p2r_shared->comp_unit_contributions = pdb_comp_unit_contribution_array_from_data(arena, contribs_data, coff_sections);
     }
   }
   lane_sync();
-  U64 exe_hash = p2r2_shared->exe_hash;
-  PDB_TpiHashParsed *tpi_hash = p2r2_shared->tpi_hash;
-  CV_LeafParsed *tpi_leaf = p2r2_shared->tpi_leaf;
-  PDB_TpiHashParsed *ipi_hash = p2r2_shared->ipi_hash;
-  CV_LeafParsed *ipi_leaf = p2r2_shared->ipi_leaf;
-  PDB_CompUnitArray *comp_units = p2r2_shared->comp_units;
-  PDB_CompUnitContributionArray *comp_unit_contributions = p2r2_shared->comp_unit_contributions;
+  U64 exe_hash = p2r_shared->exe_hash;
+  PDB_TpiHashParsed *tpi_hash = p2r_shared->tpi_hash;
+  CV_LeafParsed *tpi_leaf = p2r_shared->tpi_leaf;
+  PDB_TpiHashParsed *ipi_hash = p2r_shared->ipi_hash;
+  CV_LeafParsed *ipi_leaf = p2r_shared->ipi_leaf;
+  PDB_CompUnitArray *comp_units = p2r_shared->comp_units;
+  PDB_CompUnitContributionArray *comp_unit_contributions = p2r_shared->comp_unit_contributions;
   
   //////////////////////////////////////////////////////////////
   //- rjf: bucket compilation unit contributions
   //
   ProfScope("bucket compilation unit contributions") if(lane_idx() == 0)
   {
-    p2r2_shared->unit_ranges = push_array(arena, RDIM_Rng1U64ChunkList, comp_units->count);
+    p2r_shared->unit_ranges = push_array(arena, RDIM_Rng1U64ChunkList, comp_units->count);
     for(U64 idx = 0; idx < comp_unit_contributions->count; idx += 1)
     {
       PDB_CompUnitContribution *contribution = &comp_unit_contributions->contributions[idx];
       if(contribution->mod < comp_units->count)
       {
         RDIM_Rng1U64 r = {contribution->voff_first, contribution->voff_opl};
-        rdim_rng1u64_chunk_list_push(arena, &p2r2_shared->unit_ranges[contribution->mod], 256, r);
+        rdim_rng1u64_chunk_list_push(arena, &p2r_shared->unit_ranges[contribution->mod], 256, r);
       }
     }
   }
   lane_sync();
-  RDIM_Rng1U64ChunkList *unit_ranges = p2r2_shared->unit_ranges;
+  RDIM_Rng1U64ChunkList *unit_ranges = p2r_shared->unit_ranges;
   
   //////////////////////////////////////////////////////////////
   //- rjf: parse all syms & c13 line info streams
@@ -591,19 +591,19 @@ p2r_convert(Arena *arena, P2R_ConvertParams *params)
     //- rjf: setup outputs
     if(lane_idx() == 0)
     {
-      p2r2_shared->all_syms_count = comp_units->count+1; // +1 for global symbol stream from DBI
-      p2r2_shared->all_syms = push_array(arena, CV_SymParsed *, p2r2_shared->all_syms_count);
-      p2r2_shared->all_c13s = push_array(arena, CV_C13Parsed *, p2r2_shared->all_syms_count);
-      p2r2_shared->sym_c13_unit_lane_counter = 0;
+      p2r_shared->all_syms_count = comp_units->count+1; // +1 for global symbol stream from DBI
+      p2r_shared->all_syms = push_array(arena, CV_SymParsed *, p2r_shared->all_syms_count);
+      p2r_shared->all_c13s = push_array(arena, CV_C13Parsed *, p2r_shared->all_syms_count);
+      p2r_shared->sym_c13_unit_lane_counter = 0;
     }
     lane_sync();
     
     //- rjf: wide fill
     {
-      U64 task_count = p2r2_shared->all_syms_count;
+      U64 task_count = p2r_shared->all_syms_count;
       for(;;)
       {
-        U64 task_num = ins_atomic_u64_inc_eval(&p2r2_shared->sym_c13_unit_lane_counter);
+        U64 task_num = ins_atomic_u64_inc_eval(&p2r_shared->sym_c13_unit_lane_counter);
         if(task_num == 0 || task_count < task_num)
         {
           break;
@@ -614,21 +614,21 @@ p2r_convert(Arena *arena, P2R_ConvertParams *params)
           PDB_CompUnit *unit = comp_units->units[task_idx-1];
           String8 unit_sym_data = pdb_data_from_unit_range(msf, unit, PDB_DbiCompUnitRange_Symbols);
           String8 unit_c13_data = pdb_data_from_unit_range(msf, unit, PDB_DbiCompUnitRange_C13);
-          p2r2_shared->all_syms[task_idx] = cv_sym_from_data(arena, unit_sym_data, 4);
-          p2r2_shared->all_c13s[task_idx] = cv_c13_parsed_from_data(arena, unit_c13_data, raw_strtbl, coff_sections);
+          p2r_shared->all_syms[task_idx] = cv_sym_from_data(arena, unit_sym_data, 4);
+          p2r_shared->all_c13s[task_idx] = cv_c13_parsed_from_data(arena, unit_c13_data, raw_strtbl, coff_sections);
         }
         else
         {
           String8 global_sym_data = msf_data_from_stream(msf, dbi->sym_sn);
-          p2r2_shared->all_syms[task_idx] = cv_sym_from_data(arena, global_sym_data, 4);
+          p2r_shared->all_syms[task_idx] = cv_sym_from_data(arena, global_sym_data, 4);
         }
       }
     }
   }
   lane_sync();
-  U64 all_syms_count = p2r2_shared->all_syms_count;
-  CV_SymParsed **all_syms = p2r2_shared->all_syms;
-  CV_C13Parsed **all_c13s = p2r2_shared->all_c13s;
+  U64 all_syms_count = p2r_shared->all_syms_count;
+  CV_SymParsed **all_syms = p2r_shared->all_syms;
+  CV_C13Parsed **all_c13s = p2r_shared->all_c13s;
   
   //////////////////////////////////////////////////////////////
   //- rjf: calculate EXE's max voff
@@ -640,11 +640,11 @@ p2r_convert(Arena *arena, P2R_ConvertParams *params)
     for(;coff_sec_ptr < coff_ptr_opl; coff_sec_ptr += 1)
     {
       U64 sec_voff_max = coff_sec_ptr->voff + coff_sec_ptr->vsize;
-      p2r2_shared->exe_voff_max = Max(p2r2_shared->exe_voff_max, sec_voff_max);
+      p2r_shared->exe_voff_max = Max(p2r_shared->exe_voff_max, sec_voff_max);
     }
   }
   lane_sync();
-  U64 exe_voff_max = p2r2_shared->exe_voff_max;
+  U64 exe_voff_max = p2r_shared->exe_voff_max;
   
   //////////////////////////////////////////////////////////////
   //- rjf: determine architecture
@@ -667,15 +667,15 @@ p2r_convert(Arena *arena, P2R_ConvertParams *params)
     //
     for EachIndex(idx, all_syms_count)
     {
-      p2r2_shared->arch = p2r_rdi_arch_from_cv_arch(all_syms[idx]->info.arch);
-      if(p2r2_shared->arch != RDI_Arch_NULL)
+      p2r_shared->arch = p2r_rdi_arch_from_cv_arch(all_syms[idx]->info.arch);
+      if(p2r_shared->arch != RDI_Arch_NULL)
       {
         break;
       }
     }
   }
   lane_sync();
-  RDI_Arch arch = p2r2_shared->arch;
+  RDI_Arch arch = p2r_shared->arch;
   U64 arch_addr_size = rdi_addr_size_from_arch(arch);
   
   //////////////////////////////////////////////////////////////
@@ -688,11 +688,11 @@ p2r_convert(Arena *arena, P2R_ConvertParams *params)
     {
       rec_range_count += all_syms[idx]->sym_ranges.count;
     }
-    p2r2_shared->symbol_count_prediction = rec_range_count/8;
-    p2r2_shared->symbol_count_prediction = Max(p2r2_shared->symbol_count_prediction, 256);
+    p2r_shared->symbol_count_prediction = rec_range_count/8;
+    p2r_shared->symbol_count_prediction = Max(p2r_shared->symbol_count_prediction, 256);
   }
   lane_sync();
-  U64 symbol_count_prediction = p2r2_shared->symbol_count_prediction;
+  U64 symbol_count_prediction = p2r_shared->symbol_count_prediction;
   
   //////////////////////////////////////////////////////////////
   //- rjf: build link name map
@@ -701,8 +701,8 @@ p2r_convert(Arena *arena, P2R_ConvertParams *params)
   {
     // rjf: set up
     {
-      p2r2_shared->link_name_map.buckets_count = symbol_count_prediction;
-      p2r2_shared->link_name_map.buckets = push_array(arena, P2R_LinkNameNode *, p2r2_shared->link_name_map.buckets_count);
+      p2r_shared->link_name_map.buckets_count = symbol_count_prediction;
+      p2r_shared->link_name_map.buckets = push_array(arena, P2R_LinkNameNode *, p2r_shared->link_name_map.buckets_count);
     }
     
     // rjf: fill
@@ -744,9 +744,9 @@ p2r_convert(Arena *arena, P2R_ConvertParams *params)
             
             // rjf: commit to link name map
             U64 hash = p2r_hash_from_voff(voff);
-            U64 bucket_idx = hash%p2r2_shared->link_name_map.buckets_count;
+            U64 bucket_idx = hash%p2r_shared->link_name_map.buckets_count;
             P2R_LinkNameNode *node = push_array(arena, P2R_LinkNameNode, 1);
-            SLLStackPush(p2r2_shared->link_name_map.buckets[bucket_idx], node);
+            SLLStackPush(p2r_shared->link_name_map.buckets[bucket_idx], node);
             node->voff = voff;
             node->name = name;
           }break;
@@ -755,7 +755,7 @@ p2r_convert(Arena *arena, P2R_ConvertParams *params)
     }
   }
   lane_sync();
-  P2R_LinkNameMap link_name_map = p2r2_shared->link_name_map;
+  P2R_LinkNameMap link_name_map = p2r_shared->link_name_map;
   
   //////////////////////////////////////////////////////////////
   //- rjf: gather all file paths
@@ -765,9 +765,9 @@ p2r_convert(Arena *arena, P2R_ConvertParams *params)
     //- rjf: prep outputs
     ProfScope("prep outputs") if(lane_idx() == 0)
     {
-      p2r2_shared->unit_file_paths = push_array(arena, String8Array, comp_units->count);
-      p2r2_shared->unit_file_paths_hashes = push_array(arena, U64Array, comp_units->count);
-      p2r2_shared->sym_lane_take_counter = 0;
+      p2r_shared->unit_file_paths = push_array(arena, String8Array, comp_units->count);
+      p2r_shared->unit_file_paths_hashes = push_array(arena, U64Array, comp_units->count);
+      p2r_shared->sym_lane_take_counter = 0;
     }
     lane_sync();
     
@@ -785,7 +785,7 @@ p2r_convert(Arena *arena, P2R_ConvertParams *params)
         for(;;)
       {
         //- rjf: take next unit
-        U64 unit_num = ins_atomic_u64_inc_eval(&p2r2_shared->sym_lane_take_counter);
+        U64 unit_num = ins_atomic_u64_inc_eval(&p2r_shared->sym_lane_take_counter);
         if(unit_num > comp_units->count)
         {
           break;
@@ -1024,24 +1024,24 @@ p2r_convert(Arena *arena, P2R_ConvertParams *params)
         }
         
         //- rjf: merge into array for this unit
-        p2r2_shared->unit_file_paths[unit_idx] = str8_array_from_list(arena, &src_file_paths);
+        p2r_shared->unit_file_paths[unit_idx] = str8_array_from_list(arena, &src_file_paths);
         
         //- rjf: hash this unit's file paths
         U64Array hashes = {0};
-        hashes.count = p2r2_shared->unit_file_paths[unit_idx].count;
+        hashes.count = p2r_shared->unit_file_paths[unit_idx].count;
         hashes.v = push_array(arena, U64, hashes.count);
-        for EachIndex(idx, p2r2_shared->unit_file_paths[unit_idx].count)
+        for EachIndex(idx, p2r_shared->unit_file_paths[unit_idx].count)
         {
-          hashes.v[idx] = rdi_hash(p2r2_shared->unit_file_paths[unit_idx].v[idx].str, p2r2_shared->unit_file_paths[unit_idx].v[idx].size);
+          hashes.v[idx] = rdi_hash(p2r_shared->unit_file_paths[unit_idx].v[idx].str, p2r_shared->unit_file_paths[unit_idx].v[idx].size);
         }
-        p2r2_shared->unit_file_paths_hashes[unit_idx] = hashes;
+        p2r_shared->unit_file_paths_hashes[unit_idx] = hashes;
       }
       scratch_end(scratch);
     }
   }
   lane_sync();
-  String8Array *unit_file_paths = p2r2_shared->unit_file_paths;
-  U64Array *unit_file_paths_hashes = p2r2_shared->unit_file_paths_hashes;
+  String8Array *unit_file_paths = p2r_shared->unit_file_paths;
+  U64Array *unit_file_paths_hashes = p2r_shared->unit_file_paths_hashes;
   
   //////////////////////////////////////////////////////////////
   //- rjf: build unified collection & map for source files
@@ -1050,13 +1050,13 @@ p2r_convert(Arena *arena, P2R_ConvertParams *params)
     //- rjf: set up table
     ProfScope("set up table") if(lane_idx() == 0)
     {
-      p2r2_shared->total_path_count = 0;
+      p2r_shared->total_path_count = 0;
       for EachIndex(idx, comp_units->count)
       {
-        p2r2_shared->total_path_count += unit_file_paths[idx].count;
+        p2r_shared->total_path_count += unit_file_paths[idx].count;
       }
-      p2r2_shared->src_file_map.slots_count = p2r2_shared->total_path_count + p2r2_shared->total_path_count/2 + 1;
-      p2r2_shared->src_file_map.slots = push_array(arena, P2R_SrcFileNode *, p2r2_shared->src_file_map.slots_count);
+      p2r_shared->src_file_map.slots_count = p2r_shared->total_path_count + p2r_shared->total_path_count/2 + 1;
+      p2r_shared->src_file_map.slots = push_array(arena, P2R_SrcFileNode *, p2r_shared->src_file_map.slots_count);
     }
     lane_sync();
     
@@ -1071,9 +1071,9 @@ p2r_convert(Arena *arena, P2R_ConvertParams *params)
         {
           String8 file_path_sanitized = paths.v[path_idx];
           U64 file_path_sanitized_hash = hashes.v[path_idx];
-          U64 src_file_slot = file_path_sanitized_hash%p2r2_shared->src_file_map.slots_count;
+          U64 src_file_slot = file_path_sanitized_hash%p2r_shared->src_file_map.slots_count;
           P2R_SrcFileNode *src_file_node = 0;
-          for(P2R_SrcFileNode *n = p2r2_shared->src_file_map.slots[src_file_slot]; n != 0; n = n->next)
+          for(P2R_SrcFileNode *n = p2r_shared->src_file_map.slots[src_file_slot]; n != 0; n = n->next)
           {
             if(str8_match(n->src_file->path, file_path_sanitized, 0))
             {
@@ -1084,8 +1084,8 @@ p2r_convert(Arena *arena, P2R_ConvertParams *params)
           if(src_file_node == 0)
           {
             src_file_node = push_array(arena, P2R_SrcFileNode, 1);
-            SLLStackPush(p2r2_shared->src_file_map.slots[src_file_slot], src_file_node);
-            src_file_node->src_file = rdim_src_file_chunk_list_push(arena, &p2r2_shared->all_src_files__sequenceless, p2r2_shared->total_path_count);
+            SLLStackPush(p2r_shared->src_file_map.slots[src_file_slot], src_file_node);
+            src_file_node->src_file = rdim_src_file_chunk_list_push(arena, &p2r_shared->all_src_files__sequenceless, p2r_shared->total_path_count);
             src_file_node->src_file->path = push_str8_copy(arena, file_path_sanitized);
           }
         }
@@ -1093,8 +1093,8 @@ p2r_convert(Arena *arena, P2R_ConvertParams *params)
     }
   }
   lane_sync();
-  RDIM_SrcFileChunkList all_src_files__sequenceless = p2r2_shared->all_src_files__sequenceless;
-  P2R_SrcFileMap src_file_map = p2r2_shared->src_file_map;
+  RDIM_SrcFileChunkList all_src_files__sequenceless = p2r_shared->all_src_files__sequenceless;
+  P2R_SrcFileMap src_file_map = p2r_shared->src_file_map;
   
   //////////////////////////////////////////////////////////////
   //- rjf: convert unit info
@@ -1106,23 +1106,23 @@ p2r_convert(Arena *arena, P2R_ConvertParams *params)
     {
       for EachIndex(idx, comp_units->count)
       {
-        rdim_unit_chunk_list_push(arena, &p2r2_shared->all_units, comp_units->count);
+        rdim_unit_chunk_list_push(arena, &p2r_shared->all_units, comp_units->count);
       }
-      p2r2_shared->units_line_tables = push_array(arena, RDIM_LineTableChunkList, comp_units->count);
-      p2r2_shared->units_first_inline_site_line_tables = push_array(arena, RDIM_LineTable *, comp_units->count);
-      p2r2_shared->sym_lane_take_counter = 0;
+      p2r_shared->units_line_tables = push_array(arena, RDIM_LineTableChunkList, comp_units->count);
+      p2r_shared->units_first_inline_site_line_tables = push_array(arena, RDIM_LineTable *, comp_units->count);
+      p2r_shared->sym_lane_take_counter = 0;
     }
     lane_sync();
-    RDIM_Unit *units = p2r2_shared->all_units.first->v;
-    U64 units_count = p2r2_shared->all_units.first->count;
-    RDIM_LineTableChunkList *units_line_tables = p2r2_shared->units_line_tables;
+    RDIM_Unit *units = p2r_shared->all_units.first->v;
+    U64 units_count = p2r_shared->all_units.first->count;
+    RDIM_LineTableChunkList *units_line_tables = p2r_shared->units_line_tables;
     Assert(units_count == comp_units->count);
     
     //- rjf: do per-lane work
     ProfScope("wide fill") for(;;)
     {
       //- rjf: take next unit
-      U64 unit_num = ins_atomic_u64_inc_eval(&p2r2_shared->sym_lane_take_counter);
+      U64 unit_num = ins_atomic_u64_inc_eval(&p2r_shared->sym_lane_take_counter);
       if(unit_num > comp_units->count)
       {
         break;
@@ -1403,9 +1403,9 @@ p2r_convert(Arena *arena, P2R_ConvertParams *params)
                       if(line_table == 0)
                       {
                         line_table = rdim_line_table_chunk_list_push(arena, dst_line_tables, 256);
-                        if(p2r2_shared->units_first_inline_site_line_tables[unit_idx] == 0)
+                        if(p2r_shared->units_first_inline_site_line_tables[unit_idx] == 0)
                         {
-                          p2r2_shared->units_first_inline_site_line_tables[unit_idx] = line_table;
+                          p2r_shared->units_first_inline_site_line_tables[unit_idx] = line_table;
                         }
                       }
                       rdim_line_table_push_sequence(arena, dst_line_tables, line_table, src_file_node->src_file, voffs, line_nums, 0, line_count);
@@ -1451,9 +1451,9 @@ p2r_convert(Arena *arena, P2R_ConvertParams *params)
     }
   }
   lane_sync();
-  RDIM_UnitChunkList all_units = p2r2_shared->all_units;
-  RDIM_LineTableChunkList *units_line_tables = p2r2_shared->units_line_tables;
-  RDIM_LineTable **units_first_inline_site_line_tables = p2r2_shared->units_first_inline_site_line_tables;
+  RDIM_UnitChunkList all_units = p2r_shared->all_units;
+  RDIM_LineTableChunkList *units_line_tables = p2r_shared->units_line_tables;
+  RDIM_LineTable **units_first_inline_site_line_tables = p2r_shared->units_first_inline_site_line_tables;
   
   //////////////////////////////////////////////////////////////
   //- rjf: join all line tables
@@ -1462,11 +1462,11 @@ p2r_convert(Arena *arena, P2R_ConvertParams *params)
   {
     for EachIndex(idx, comp_units->count)
     {
-      rdim_line_table_chunk_list_concat_in_place(&p2r2_shared->all_line_tables, &units_line_tables[idx]);
+      rdim_line_table_chunk_list_concat_in_place(&p2r_shared->all_line_tables, &units_line_tables[idx]);
     }
   }
   lane_sync();
-  RDIM_LineTableChunkList all_line_tables = p2r2_shared->all_line_tables;
+  RDIM_LineTableChunkList all_line_tables = p2r_shared->all_line_tables;
   
   //////////////////////////////////////////////////////////////
   //- rjf: equip source files with line sequences
@@ -1482,13 +1482,13 @@ p2r_convert(Arena *arena, P2R_ConvertParams *params)
         RDIM_LineTable *line_table = &line_table_chunk_n->v[chunk_line_table_idx];
         for(RDIM_LineSequenceNode *s = line_table->first_seq; s != 0; s = s->next)
         {
-          rdim_src_file_push_line_sequence(arena, &p2r2_shared->all_src_files__sequenceless, s->v.src_file, &s->v);
+          rdim_src_file_push_line_sequence(arena, &p2r_shared->all_src_files__sequenceless, s->v.src_file, &s->v);
         }
       }
     }
   }
   lane_sync();
-  RDIM_SrcFileChunkList all_src_files = p2r2_shared->all_src_files__sequenceless;
+  RDIM_SrcFileChunkList all_src_files = p2r_shared->all_src_files__sequenceless;
   
   //////////////////////////////////////////////////////////////
   //- rjf: types pass 1: produce type forward resolution map
@@ -1504,19 +1504,19 @@ p2r_convert(Arena *arena, P2R_ConvertParams *params)
     //- rjf: allocate forward resolution map
     if(lane_idx() == 0)
     {
-      p2r2_shared->itype_first = tpi_leaf->itype_first;
-      p2r2_shared->itype_opl = tpi_leaf->itype_opl;
-      p2r2_shared->itype_fwd_map = push_array(arena, CV_TypeId, (U64)p2r2_shared->itype_opl);
+      p2r_shared->itype_first = tpi_leaf->itype_first;
+      p2r_shared->itype_opl = tpi_leaf->itype_opl;
+      p2r_shared->itype_fwd_map = push_array(arena, CV_TypeId, (U64)p2r_shared->itype_opl);
     }
     lane_sync();
     
     //- rjf: do wide fill
     {
-      Rng1U64 range = lane_range(p2r2_shared->itype_opl);
+      Rng1U64 range = lane_range(p2r_shared->itype_opl);
       for EachInRange(idx, range)
       {
         CV_TypeId itype = (CV_TypeId)idx;
-        if(itype < p2r2_shared->itype_first) { continue; }
+        if(itype < p2r_shared->itype_first) { continue; }
         
         //- rjf: determine if this itype resolves to another
         CV_TypeId itype_fwd = 0;
@@ -1628,15 +1628,15 @@ p2r_convert(Arena *arena, P2R_ConvertParams *params)
         //- rjf: if the forwarded itype is nonzero & in TPI range -> save to map
         if(itype_fwd != 0 && itype_fwd < tpi_leaf->itype_opl)
         {
-          p2r2_shared->itype_fwd_map[itype] = itype_fwd;
+          p2r_shared->itype_fwd_map[itype] = itype_fwd;
         }
       }
     }
   }
   lane_sync();
-  CV_TypeId *itype_fwd_map = p2r2_shared->itype_fwd_map;
-  CV_TypeId itype_first = p2r2_shared->itype_first;
-  CV_TypeId itype_opl = p2r2_shared->itype_opl;
+  CV_TypeId *itype_fwd_map = p2r_shared->itype_fwd_map;
+  CV_TypeId itype_first = p2r_shared->itype_first;
+  CV_TypeId itype_opl = p2r_shared->itype_opl;
   
   //////////////////////////////////////////////////////////////
   //- rjf: types pass 2: produce per-itype itype chain
@@ -1653,23 +1653,23 @@ p2r_convert(Arena *arena, P2R_ConvertParams *params)
     //- rjf: allocate itype chain table
     if(lane_idx() == 0)
     {
-      p2r2_shared->itype_chains = push_array(arena, P2R_TypeIdChain *, (U64)p2r2_shared->itype_opl);
+      p2r_shared->itype_chains = push_array(arena, P2R_TypeIdChain *, (U64)p2r_shared->itype_opl);
     }
     lane_sync();
     
     //- rjf: do wide fill
     {
-      Rng1U64 range = lane_range(p2r2_shared->itype_opl);
+      Rng1U64 range = lane_range(p2r_shared->itype_opl);
       for EachInRange(idx, range)
       {
         CV_TypeId itype = (CV_TypeId)idx;
-        if(itype < p2r2_shared->itype_first) { continue; }
+        if(itype < p2r_shared->itype_first) { continue; }
         
         //- rjf: push initial itype - should be final-visited-itype for this itype
         {
           P2R_TypeIdChain *c = push_array(arena, P2R_TypeIdChain, 1);
           c->itype = itype;
-          SLLStackPush(p2r2_shared->itype_chains[itype], c);
+          SLLStackPush(p2r_shared->itype_chains[itype], c);
         }
         
         //- rjf: skip basic types for dependency walk
@@ -1714,7 +1714,7 @@ p2r_convert(Arena *arena, P2R_ConvertParams *params)
                 {
                   P2R_TypeIdChain *c = push_array(arena, P2R_TypeIdChain, 1);
                   c->itype = lf->itype;
-                  SLLStackPush(p2r2_shared->itype_chains[itype], c);
+                  SLLStackPush(p2r_shared->itype_chains[itype], c);
                 }
                 
                 // rjf: push task to walk dependency itype
@@ -1734,7 +1734,7 @@ p2r_convert(Arena *arena, P2R_ConvertParams *params)
                 {
                   P2R_TypeIdChain *c = push_array(arena, P2R_TypeIdChain, 1);
                   c->itype = lf->itype;
-                  SLLStackPush(p2r2_shared->itype_chains[itype], c);
+                  SLLStackPush(p2r_shared->itype_chains[itype], c);
                 }
                 
                 // rjf: push task to walk dependency itype
@@ -1754,7 +1754,7 @@ p2r_convert(Arena *arena, P2R_ConvertParams *params)
                 {
                   P2R_TypeIdChain *c = push_array(arena, P2R_TypeIdChain, 1);
                   c->itype = lf->ret_itype;
-                  SLLStackPush(p2r2_shared->itype_chains[itype], c);
+                  SLLStackPush(p2r_shared->itype_chains[itype], c);
                 }
                 
                 // rjf: push task to walk return itype
@@ -1789,7 +1789,7 @@ p2r_convert(Arena *arena, P2R_ConvertParams *params)
                 {
                   P2R_TypeIdChain *c = push_array(arena, P2R_TypeIdChain, 1);
                   c->itype = arglist_itypes_base[idx];
-                  SLLStackPush(p2r2_shared->itype_chains[itype], c);
+                  SLLStackPush(p2r_shared->itype_chains[itype], c);
                 }
                 
                 // rjf: push task to walk arg types
@@ -1810,17 +1810,17 @@ p2r_convert(Arena *arena, P2R_ConvertParams *params)
                 {
                   P2R_TypeIdChain *c = push_array(arena, P2R_TypeIdChain, 1);
                   c->itype = lf->ret_itype;
-                  SLLStackPush(p2r2_shared->itype_chains[itype], c);
+                  SLLStackPush(p2r_shared->itype_chains[itype], c);
                 }
                 {
                   P2R_TypeIdChain *c = push_array(arena, P2R_TypeIdChain, 1);
                   c->itype = lf->arg_itype;
-                  SLLStackPush(p2r2_shared->itype_chains[itype], c);
+                  SLLStackPush(p2r_shared->itype_chains[itype], c);
                 }
                 {
                   P2R_TypeIdChain *c = push_array(arena, P2R_TypeIdChain, 1);
                   c->itype = lf->this_itype;
-                  SLLStackPush(p2r2_shared->itype_chains[itype], c);
+                  SLLStackPush(p2r_shared->itype_chains[itype], c);
                 }
                 
                 // rjf: push task to walk dependency itypes
@@ -1865,7 +1865,7 @@ p2r_convert(Arena *arena, P2R_ConvertParams *params)
                 {
                   P2R_TypeIdChain *c = push_array(arena, P2R_TypeIdChain, 1);
                   c->itype = arglist_itypes_base[idx];
-                  SLLStackPush(p2r2_shared->itype_chains[itype], c);
+                  SLLStackPush(p2r_shared->itype_chains[itype], c);
                 }
                 
                 // rjf: push task to walk arg types
@@ -1886,7 +1886,7 @@ p2r_convert(Arena *arena, P2R_ConvertParams *params)
                 {
                   P2R_TypeIdChain *c = push_array(arena, P2R_TypeIdChain, 1);
                   c->itype = lf->itype;
-                  SLLStackPush(p2r2_shared->itype_chains[itype], c);
+                  SLLStackPush(p2r_shared->itype_chains[itype], c);
                 }
                 
                 // rjf: push task to walk dependency itype
@@ -1906,12 +1906,12 @@ p2r_convert(Arena *arena, P2R_ConvertParams *params)
                 {
                   P2R_TypeIdChain *c = push_array(arena, P2R_TypeIdChain, 1);
                   c->itype = lf->entry_itype;
-                  SLLStackPush(p2r2_shared->itype_chains[itype], c);
+                  SLLStackPush(p2r_shared->itype_chains[itype], c);
                 }
                 {
                   P2R_TypeIdChain *c = push_array(arena, P2R_TypeIdChain, 1);
                   c->itype = lf->index_itype;
-                  SLLStackPush(p2r2_shared->itype_chains[itype], c);
+                  SLLStackPush(p2r_shared->itype_chains[itype], c);
                 }
                 
                 // rjf: push task to walk dependency itypes
@@ -1936,7 +1936,7 @@ p2r_convert(Arena *arena, P2R_ConvertParams *params)
                 {
                   P2R_TypeIdChain *c = push_array(arena, P2R_TypeIdChain, 1);
                   c->itype = lf->base_itype;
-                  SLLStackPush(p2r2_shared->itype_chains[itype], c);
+                  SLLStackPush(p2r_shared->itype_chains[itype], c);
                 }
                 
                 // rjf: push task to walk dependency itypes
@@ -1954,7 +1954,7 @@ p2r_convert(Arena *arena, P2R_ConvertParams *params)
     }
   }
   lane_sync();
-  P2R_TypeIdChain **itype_chains = p2r2_shared->itype_chains;
+  P2R_TypeIdChain **itype_chains = p2r_shared->itype_chains;
   
   //////////////////////////////////////////////////////////////
   //- rjf: types pass 3: construct all types from TPI
@@ -2494,16 +2494,16 @@ p2r_convert(Arena *arena, P2R_ConvertParams *params)
         }
       }
     }
-    p2r2_shared->itype_type_ptrs = itype_type_ptrs;
-    p2r2_shared->basic_type_ptrs = basic_type_ptrs;
-    p2r2_shared->all_types__pre_typedefs = all_types;
+    p2r_shared->itype_type_ptrs = itype_type_ptrs;
+    p2r_shared->basic_type_ptrs = basic_type_ptrs;
+    p2r_shared->all_types__pre_typedefs = all_types;
 #undef p2r_type_ptr_from_itype
 #undef p2r_builtin_type_ptr_from_kind
   }
   lane_sync();
-  RDIM_Type **itype_type_ptrs = p2r2_shared->itype_type_ptrs;
-  RDIM_Type **basic_type_ptrs = p2r2_shared->basic_type_ptrs;
-  RDIM_TypeChunkList all_types__pre_typedefs = p2r2_shared->all_types__pre_typedefs;
+  RDIM_Type **itype_type_ptrs = p2r_shared->itype_type_ptrs;
+  RDIM_Type **basic_type_ptrs = p2r_shared->basic_type_ptrs;
+  RDIM_TypeChunkList all_types__pre_typedefs = p2r_shared->all_types__pre_typedefs;
   
   //////////////////////////////////////////////////////////////
   //- rjf: types pass 4: build UDTs
@@ -2515,14 +2515,14 @@ p2r_convert(Arena *arena, P2R_ConvertParams *params)
     //- rjf: set up
     if(lane_idx() == 0)
     {
-      p2r2_shared->lanes_udts = push_array(arena, RDIM_UDTChunkList, lane_count());
+      p2r_shared->lanes_udts = push_array(arena, RDIM_UDTChunkList, lane_count());
     }
     lane_sync();
     
     //- rjf: do wide fill
     {
       U64 udts_chunk_cap = 4096;
-      RDIM_UDTChunkList *udts = &p2r2_shared->lanes_udts[lane_idx()];
+      RDIM_UDTChunkList *udts = &p2r_shared->lanes_udts[lane_idx()];
       Rng1U64 range = lane_range(itype_opl);
       for EachInRange(idx, range)
       {
@@ -3145,7 +3145,7 @@ p2r_convert(Arena *arena, P2R_ConvertParams *params)
 #undef p2r_type_ptr_from_itype
   }
   lane_sync();
-  RDIM_UDTChunkList *lanes_udts = p2r2_shared->lanes_udts;
+  RDIM_UDTChunkList *lanes_udts = p2r_shared->lanes_udts;
   
   //////////////////////////////////////////////////////////////
   //- rjf: join all UDTs
@@ -3154,11 +3154,11 @@ p2r_convert(Arena *arena, P2R_ConvertParams *params)
   {
     for EachIndex(idx, lane_count())
     {
-      rdim_udt_chunk_list_concat_in_place(&p2r2_shared->all_udts, &lanes_udts[idx]);
+      rdim_udt_chunk_list_concat_in_place(&p2r_shared->all_udts, &lanes_udts[idx]);
     }
   }
   lane_sync();
-  RDIM_UDTChunkList all_udts = p2r2_shared->all_udts;
+  RDIM_UDTChunkList all_udts = p2r_shared->all_udts;
   
   //////////////////////////////////////////////////////////////
   //- rjf: produce symbols from all streams
@@ -3172,15 +3172,15 @@ p2r_convert(Arena *arena, P2R_ConvertParams *params)
     //
     if(lane_idx() == 0)
     {
-      p2r2_shared->syms_locations        = push_array(arena, RDIM_LocationChunkList, all_syms_count);
-      p2r2_shared->syms_procedures       = push_array(arena, RDIM_SymbolChunkList, all_syms_count);
-      p2r2_shared->syms_global_variables = push_array(arena, RDIM_SymbolChunkList, all_syms_count);
-      p2r2_shared->syms_thread_variables = push_array(arena, RDIM_SymbolChunkList, all_syms_count);
-      p2r2_shared->syms_constants        = push_array(arena, RDIM_SymbolChunkList, all_syms_count);
-      p2r2_shared->syms_scopes           = push_array(arena, RDIM_ScopeChunkList, all_syms_count);
-      p2r2_shared->syms_inline_sites     = push_array(arena, RDIM_InlineSiteChunkList, all_syms_count);
-      p2r2_shared->syms_typedefs         = push_array(arena, RDIM_TypeChunkList, all_syms_count);
-      p2r2_shared->sym_lane_take_counter  = 0;
+      p2r_shared->syms_locations        = push_array(arena, RDIM_LocationChunkList, all_syms_count);
+      p2r_shared->syms_procedures       = push_array(arena, RDIM_SymbolChunkList, all_syms_count);
+      p2r_shared->syms_global_variables = push_array(arena, RDIM_SymbolChunkList, all_syms_count);
+      p2r_shared->syms_thread_variables = push_array(arena, RDIM_SymbolChunkList, all_syms_count);
+      p2r_shared->syms_constants        = push_array(arena, RDIM_SymbolChunkList, all_syms_count);
+      p2r_shared->syms_scopes           = push_array(arena, RDIM_ScopeChunkList, all_syms_count);
+      p2r_shared->syms_inline_sites     = push_array(arena, RDIM_InlineSiteChunkList, all_syms_count);
+      p2r_shared->syms_typedefs         = push_array(arena, RDIM_TypeChunkList, all_syms_count);
+      p2r_shared->sym_lane_take_counter  = 0;
     }
     lane_sync();
     
@@ -3190,7 +3190,7 @@ p2r_convert(Arena *arena, P2R_ConvertParams *params)
     for(;;)
     {
       //- rjf: take next sym
-      U64 sym_num = ins_atomic_u64_inc_eval(&p2r2_shared->sym_lane_take_counter);
+      U64 sym_num = ins_atomic_u64_inc_eval(&p2r_shared->sym_lane_take_counter);
       if(sym_num > all_syms_count)
       {
         break;
@@ -3208,14 +3208,14 @@ p2r_convert(Arena *arena, P2R_ConvertParams *params)
       U64 sym_constants_chunk_cap = 16384;
       U64 sym_scopes_chunk_cap = 16384;
       U64 sym_inline_sites_chunk_cap = 16384;
-      RDIM_LocationChunkList *sym_locations = &p2r2_shared->syms_locations[sym_idx];
-      RDIM_SymbolChunkList *sym_procedures = &p2r2_shared->syms_procedures[sym_idx];
-      RDIM_SymbolChunkList *sym_global_variables = &p2r2_shared->syms_global_variables[sym_idx];
-      RDIM_SymbolChunkList *sym_thread_variables = &p2r2_shared->syms_thread_variables[sym_idx];
-      RDIM_SymbolChunkList *sym_constants = &p2r2_shared->syms_constants[sym_idx];
-      RDIM_ScopeChunkList *sym_scopes = &p2r2_shared->syms_scopes[sym_idx];
-      RDIM_InlineSiteChunkList *sym_inline_sites = &p2r2_shared->syms_inline_sites[sym_idx];
-      RDIM_TypeChunkList *typedefs = &p2r2_shared->syms_typedefs[sym_idx];
+      RDIM_LocationChunkList *sym_locations = &p2r_shared->syms_locations[sym_idx];
+      RDIM_SymbolChunkList *sym_procedures = &p2r_shared->syms_procedures[sym_idx];
+      RDIM_SymbolChunkList *sym_global_variables = &p2r_shared->syms_global_variables[sym_idx];
+      RDIM_SymbolChunkList *sym_thread_variables = &p2r_shared->syms_thread_variables[sym_idx];
+      RDIM_SymbolChunkList *sym_constants = &p2r_shared->syms_constants[sym_idx];
+      RDIM_ScopeChunkList *sym_scopes = &p2r_shared->syms_scopes[sym_idx];
+      RDIM_InlineSiteChunkList *sym_inline_sites = &p2r_shared->syms_inline_sites[sym_idx];
+      RDIM_TypeChunkList *typedefs = &p2r_shared->syms_typedefs[sym_idx];
       
       //////////////////////////
       //- rjf: symbols pass 1: produce procedure frame info map (procedure -> frame info)
@@ -3634,7 +3634,7 @@ p2r_convert(Arena *arena, P2R_ConvertParams *params)
                 U32 byte_pos = 0;
                 
                 // rjf: build location
-                RDIM_LocationInfo loc_info = p2r2_location_info_from_addr_reg_off(arena, arch, reg_code, byte_size, byte_pos, (S64)(S32)var_off, extra_indirection_to_value);
+                RDIM_LocationInfo loc_info = p2r_location_info_from_addr_reg_off(arena, arch, reg_code, byte_size, byte_pos, (S64)(S32)var_off, extra_indirection_to_value);
                 RDIM_Location *loc2 = rdim_location_chunk_list_push_new(arena, sym_locations, sym_locations_chunk_cap, &loc_info);
                 RDIM_Rng1U64 voff_range = {0, max_U64};
                 rdim_local_push_location_case(arena, sym_scopes, local, loc2, voff_range);
@@ -3756,7 +3756,7 @@ p2r_convert(Arena *arena, P2R_ConvertParams *params)
               RDIM_Location *loc = rdim_location_chunk_list_push_new(arena, sym_locations, sym_locations_chunk_cap, &loc_info);
               
               // rjf: emit locations over ranges
-              p2r2_local_push_location_cases_over_lvar_addr_range(arena, sym_scopes, defrange_target, loc, range, range_section, gaps, gap_count);
+              p2r_local_push_location_cases_over_lvar_addr_range(arena, sym_scopes, defrange_target, loc, range, range_section, gaps, gap_count);
             }break;
             
             //- rjf: DEFRANGE_FRAMEPOINTER_REL
@@ -3799,11 +3799,11 @@ p2r_convert(Arena *arena, P2R_ConvertParams *params)
               U32 byte_size = rdi_addr_size_from_arch(arch);
               U32 byte_pos = 0;
               S64 var_off = (S64)defrange_fprel->off;
-              RDIM_LocationInfo location_info = p2r2_location_info_from_addr_reg_off(arena, arch, fp_register_code, byte_size, byte_pos, var_off, extra_indirection);
+              RDIM_LocationInfo location_info = p2r_location_info_from_addr_reg_off(arena, arch, fp_register_code, byte_size, byte_pos, var_off, extra_indirection);
               RDIM_Location *location = rdim_location_chunk_list_push_new(arena, sym_locations, sym_locations_chunk_cap, &location_info);
               
               // rjf: emit locations over ranges
-              p2r2_local_push_location_cases_over_lvar_addr_range(arena, sym_scopes, defrange_target, location, range, range_section, gaps, gap_count);
+              p2r_local_push_location_cases_over_lvar_addr_range(arena, sym_scopes, defrange_target, location, range, range_section, gaps, gap_count);
             }break;
             
             //- rjf: DEFRANGE_SUBFIELD_REGISTER
@@ -3836,7 +3836,7 @@ p2r_convert(Arena *arena, P2R_ConvertParams *params)
               RDIM_Location *loc = rdim_location_chunk_list_push_new(arena, sym_locations, sym_locations_chunk_cap, &loc_info);
               
               // rjf: emit locations over ranges
-              p2r2_local_push_location_cases_over_lvar_addr_range(arena, sym_scopes, defrange_target, loc, range, range_section, gaps, gap_count);
+              p2r_local_push_location_cases_over_lvar_addr_range(arena, sym_scopes, defrange_target, loc, range, range_section, gaps, gap_count);
             }break;
             
             //- rjf: DEFRANGE_FRAMEPOINTER_REL_FULL_SCOPE
@@ -3873,7 +3873,7 @@ p2r_convert(Arena *arena, P2R_ConvertParams *params)
               U32 byte_size = rdi_addr_size_from_arch(arch);
               U32 byte_pos = 0;
               S64 var_off = (S64)defrange_fprel_full_scope->off;
-              RDIM_LocationInfo loc_info = p2r2_location_info_from_addr_reg_off(arena, arch, fp_register_code, byte_size, byte_pos, var_off, extra_indirection);
+              RDIM_LocationInfo loc_info = p2r_location_info_from_addr_reg_off(arena, arch, fp_register_code, byte_size, byte_pos, var_off, extra_indirection);
               RDIM_Location *loc = rdim_location_chunk_list_push_new(arena, sym_locations, sym_locations_chunk_cap, &loc_info);
               
               // rjf: emit location over ranges
@@ -3906,11 +3906,11 @@ p2r_convert(Arena *arena, P2R_ConvertParams *params)
               U32 byte_pos = 0;
               B32 extra_indirection_to_value = 0;
               S64 var_off = defrange_register_rel->reg_off;
-              RDIM_LocationInfo loc_info = p2r2_location_info_from_addr_reg_off(arena, arch, reg_code, byte_size, byte_pos, var_off, extra_indirection_to_value);
+              RDIM_LocationInfo loc_info = p2r_location_info_from_addr_reg_off(arena, arch, reg_code, byte_size, byte_pos, var_off, extra_indirection_to_value);
               RDIM_Location *loc = rdim_location_chunk_list_push_new(arena, sym_locations, sym_locations_chunk_cap, &loc_info);
               
               // rjf: emit locations over ranges
-              p2r2_local_push_location_cases_over_lvar_addr_range(arena, sym_scopes, defrange_target, loc, range, range_section, gaps, gap_count);
+              p2r_local_push_location_cases_over_lvar_addr_range(arena, sym_scopes, defrange_target, loc, range, range_section, gaps, gap_count);
             }break;
             
             //- rjf: FILESTATIC
@@ -4106,69 +4106,69 @@ p2r_convert(Arena *arena, P2R_ConvertParams *params)
     {
       for EachIndex(idx, all_syms_count)
       {
-        rdim_location_chunk_list_concat_in_place(&p2r2_shared->all_locations, &p2r2_shared->syms_locations[idx]);
+        rdim_location_chunk_list_concat_in_place(&p2r_shared->all_locations, &p2r_shared->syms_locations[idx]);
       }
     }
     if(lane_idx() == lane_from_task_idx(1)) ProfScope("join procedures")
     {
       for EachIndex(idx, all_syms_count)
       {
-        rdim_symbol_chunk_list_concat_in_place(&p2r2_shared->all_procedures, &p2r2_shared->syms_procedures[idx]);
+        rdim_symbol_chunk_list_concat_in_place(&p2r_shared->all_procedures, &p2r_shared->syms_procedures[idx]);
       }
     }
     if(lane_idx() == lane_from_task_idx(2)) ProfScope("join global variables")
     {
       for EachIndex(idx, all_syms_count)
       {
-        rdim_symbol_chunk_list_concat_in_place(&p2r2_shared->all_global_variables, &p2r2_shared->syms_global_variables[idx]);
+        rdim_symbol_chunk_list_concat_in_place(&p2r_shared->all_global_variables, &p2r_shared->syms_global_variables[idx]);
       }
     }
     if(lane_idx() == lane_from_task_idx(3)) ProfScope("join thread variables")
     {
       for EachIndex(idx, all_syms_count)
       {
-        rdim_symbol_chunk_list_concat_in_place(&p2r2_shared->all_thread_variables, &p2r2_shared->syms_thread_variables[idx]);
+        rdim_symbol_chunk_list_concat_in_place(&p2r_shared->all_thread_variables, &p2r_shared->syms_thread_variables[idx]);
       }
     }
     if(lane_idx() == lane_from_task_idx(4)) ProfScope("join constants")
     {
       for EachIndex(idx, all_syms_count)
       {
-        rdim_symbol_chunk_list_concat_in_place(&p2r2_shared->all_constants, &p2r2_shared->syms_constants[idx]);
+        rdim_symbol_chunk_list_concat_in_place(&p2r_shared->all_constants, &p2r_shared->syms_constants[idx]);
       }
     }
     if(lane_idx() == lane_from_task_idx(5)) ProfScope("join scopes")
     {
       for EachIndex(idx, all_syms_count)
       {
-        rdim_scope_chunk_list_concat_in_place(&p2r2_shared->all_scopes, &p2r2_shared->syms_scopes[idx]);
+        rdim_scope_chunk_list_concat_in_place(&p2r_shared->all_scopes, &p2r_shared->syms_scopes[idx]);
       }
     }
     if(lane_idx() == lane_from_task_idx(6)) ProfScope("join inline sites")
     {
       for EachIndex(idx, all_syms_count)
       {
-        rdim_inline_site_chunk_list_concat_in_place(&p2r2_shared->all_inline_sites, &p2r2_shared->syms_inline_sites[idx]);
+        rdim_inline_site_chunk_list_concat_in_place(&p2r_shared->all_inline_sites, &p2r_shared->syms_inline_sites[idx]);
       }
     }
     if(lane_idx() == lane_from_task_idx(7)) ProfScope("join typedefs")
     {
       for EachIndex(idx, all_syms_count)
       {
-        rdim_type_chunk_list_concat_in_place(&p2r2_shared->all_types__pre_typedefs, &p2r2_shared->syms_typedefs[idx]);
+        rdim_type_chunk_list_concat_in_place(&p2r_shared->all_types__pre_typedefs, &p2r_shared->syms_typedefs[idx]);
       }
-      p2r2_shared->all_types = p2r2_shared->all_types__pre_typedefs;
+      p2r_shared->all_types = p2r_shared->all_types__pre_typedefs;
     }
   }
   lane_sync();
-  RDIM_LocationChunkList all_locations           = p2r2_shared->all_locations;
-  RDIM_SymbolChunkList all_procedures            = p2r2_shared->all_procedures;
-  RDIM_SymbolChunkList all_global_variables      = p2r2_shared->all_global_variables;
-  RDIM_SymbolChunkList all_thread_variables      = p2r2_shared->all_thread_variables;
-  RDIM_SymbolChunkList all_constants             = p2r2_shared->all_constants;
-  RDIM_ScopeChunkList all_scopes                 = p2r2_shared->all_scopes;
-  RDIM_InlineSiteChunkList all_inline_sites      = p2r2_shared->all_inline_sites;
-  RDIM_TypeChunkList all_types                   = p2r2_shared->all_types;
+  RDIM_LocationChunkList all_locations           = p2r_shared->all_locations;
+  RDIM_SymbolChunkList all_procedures            = p2r_shared->all_procedures;
+  RDIM_SymbolChunkList all_global_variables      = p2r_shared->all_global_variables;
+  RDIM_SymbolChunkList all_thread_variables      = p2r_shared->all_thread_variables;
+  RDIM_SymbolChunkList all_constants             = p2r_shared->all_constants;
+  RDIM_ScopeChunkList all_scopes                 = p2r_shared->all_scopes;
+  RDIM_InlineSiteChunkList all_inline_sites      = p2r_shared->all_inline_sites;
+  RDIM_TypeChunkList all_types                   = p2r_shared->all_types;
   
   //////////////////////////////////////////////////////////////
   //- rjf: bundle all outputs
diff --git a/src/rdi_from_pdb/rdi_from_pdb.h b/src/rdi_from_pdb/rdi_from_pdb.h
index 3682e0f7..9cf33904 100644
--- a/src/rdi_from_pdb/rdi_from_pdb.h
+++ b/src/rdi_from_pdb/rdi_from_pdb.h
@@ -67,8 +67,8 @@ struct P2R_TypeIdChain
 
 //- rjf: main state bundle
 
-typedef struct P2R2_Shared P2R2_Shared;
-struct P2R2_Shared
+typedef struct P2R_Shared P2R_Shared;
+struct P2R_Shared
 {
   MSF_RawStreamTable *msf_raw_stream_table;
   U64 msf_stream_lane_counter;
@@ -159,7 +159,7 @@ struct P2R2_Shared
 ////////////////////////////////
 //~ rjf: Globals
 
-global P2R2_Shared *p2r2_shared = 0;
+global P2R_Shared *p2r_shared = 0;
 
 ////////////////////////////////
 //~ rjf: Basic Helpers
@@ -184,8 +184,8 @@ internal RDI_TypeKind p2r_rdi_type_kind_from_cv_basic_type(CV_BasicType basic_ty
 //~ rjf: Location Info Building Helpers
 
 internal RDI_RegCode p2r_reg_code_from_arch_encoded_fp_reg(RDI_Arch arch, CV_EncodedFramePtrReg encoded_reg);
-internal RDIM_LocationInfo p2r2_location_info_from_addr_reg_off(Arena *arena, RDI_Arch arch, RDI_RegCode reg_code, U32 reg_byte_size, U32 reg_byte_pos, S64 offset, B32 extra_indirection);
-internal void p2r2_local_push_location_cases_over_lvar_addr_range(Arena *arena, RDIM_ScopeChunkList *scopes, RDIM_Local *local, RDIM_Location *loc, CV_LvarAddrRange *range, COFF_SectionHeader *section, CV_LvarAddrGap *gaps, U64 gap_count);
+internal RDIM_LocationInfo p2r_location_info_from_addr_reg_off(Arena *arena, RDI_Arch arch, RDI_RegCode reg_code, U32 reg_byte_size, U32 reg_byte_pos, S64 offset, B32 extra_indirection);
+internal void p2r_local_push_location_cases_over_lvar_addr_range(Arena *arena, RDIM_ScopeChunkList *scopes, RDIM_Local *local, RDIM_Location *loc, CV_LvarAddrRange *range, COFF_SectionHeader *section, CV_LvarAddrGap *gaps, U64 gap_count);
 
 ////////////////////////////////
 //~ rjf: Top-Level Conversion Entry Point
diff --git a/src/rdi_make/rdi_make_local.c b/src/rdi_make/rdi_make_local.c
index 14f1839d..e886f697 100644
--- a/src/rdi_make/rdi_make_local.c
+++ b/src/rdi_make/rdi_make_local.c
@@ -49,14 +49,14 @@ rdim_make_top_level_info(String8 image_name, Arch arch, U64 exe_hash, RDIM_Binar
 }
 
 internal RDIM_BakeResults
-rdim2_bake(Arena *arena, RDIM_BakeParams *params)
+rdim_bake(Arena *arena, RDIM_BakeParams *params)
 {
   //////////////////////////////////////////////////////////////
   //- rjf: set up shared state
   //
   if(lane_idx() == 0)
   {
-    rdim2_shared = push_array(arena, RDIM2_Shared, 1);
+    rdim_shared = push_array(arena, RDIM_Shared, 1);
   }
   lane_sync();
   
@@ -68,14 +68,14 @@ rdim2_bake(Arena *arena, RDIM_BakeParams *params)
     //- rjf: gather scope vmap keys/markers
     if(lane_idx() == lane_from_task_idx(0)) ProfScope("gather scope vmap keys/markers")
     {
-      rdim2_shared->scope_vmap_count = params->scopes.scope_voff_count;
-      rdim2_shared->scope_vmap_keys = push_array_no_zero(arena, RDIM_SortKey, rdim2_shared->scope_vmap_count);
-      rdim2_shared->scope_vmap_keys__swap = push_array_no_zero(arena, RDIM_SortKey, rdim2_shared->scope_vmap_count);
-      rdim2_shared->scope_vmap_markers = push_array_no_zero(arena, RDIM_VMapMarker, rdim2_shared->scope_vmap_count);
+      rdim_shared->scope_vmap_count = params->scopes.scope_voff_count;
+      rdim_shared->scope_vmap_keys = push_array_no_zero(arena, RDIM_SortKey, rdim_shared->scope_vmap_count);
+      rdim_shared->scope_vmap_keys__swap = push_array_no_zero(arena, RDIM_SortKey, rdim_shared->scope_vmap_count);
+      rdim_shared->scope_vmap_markers = push_array_no_zero(arena, RDIM_VMapMarker, rdim_shared->scope_vmap_count);
       ProfScope("fill keys/markers")
       {
-        RDIM_SortKey *key_ptr = rdim2_shared->scope_vmap_keys;
-        RDIM_VMapMarker *marker_ptr = rdim2_shared->scope_vmap_markers;
+        RDIM_SortKey *key_ptr = rdim_shared->scope_vmap_keys;
+        RDIM_VMapMarker *marker_ptr = rdim_shared->scope_vmap_markers;
         for(RDIM_ScopeChunkNode *chunk_n = params->scopes.first; chunk_n != 0; chunk_n = chunk_n->next)
         {
           for(RDI_U64 chunk_idx = 0; chunk_idx < chunk_n->count; chunk_idx += 1)
@@ -163,10 +163,10 @@ rdim2_bake(Arena *arena, RDIM_BakeParams *params)
       }
       
       // rjf: store
-      rdim2_shared->unit_vmap_count = marker_count;
-      rdim2_shared->unit_vmap_keys = keys;
-      rdim2_shared->unit_vmap_keys__swap = push_array_no_zero(arena, RDIM_SortKey, marker_count);
-      rdim2_shared->unit_vmap_markers = markers;
+      rdim_shared->unit_vmap_count = marker_count;
+      rdim_shared->unit_vmap_keys = keys;
+      rdim_shared->unit_vmap_keys__swap = push_array_no_zero(arena, RDIM_SortKey, marker_count);
+      rdim_shared->unit_vmap_markers = markers;
     }
     
     //- rjf: gather global vmap keys/markers
@@ -231,10 +231,10 @@ rdim2_bake(Arena *arena, RDIM_BakeParams *params)
       }
       
       //- rjf: store
-      rdim2_shared->global_vmap_count = marker_count;
-      rdim2_shared->global_vmap_keys = keys;
-      rdim2_shared->global_vmap_keys__swap = push_array_no_zero(arena, RDIM_SortKey, marker_count);
-      rdim2_shared->global_vmap_markers = markers;
+      rdim_shared->global_vmap_count = marker_count;
+      rdim_shared->global_vmap_keys = keys;
+      rdim_shared->global_vmap_keys__swap = push_array_no_zero(arena, RDIM_SortKey, marker_count);
+      rdim_shared->global_vmap_markers = markers;
     }
   }
   lane_sync();
@@ -247,8 +247,8 @@ rdim2_bake(Arena *arena, RDIM_BakeParams *params)
     // rjf: set up
     if(lane_idx() == 0)
     {
-      rdim2_shared->lane_digit_counts = push_array(arena, U32 *, lane_count());
-      rdim2_shared->lane_digit_offsets = push_array(arena, U32 *, lane_count());
+      rdim_shared->lane_digit_counts = push_array(arena, U32 *, lane_count());
+      rdim_shared->lane_digit_offsets = push_array(arena, U32 *, lane_count());
     }
     lane_sync();
     
@@ -261,9 +261,9 @@ rdim2_bake(Arena *arena, RDIM_BakeParams *params)
     }
     sort_tasks[] =
     {
-      {rdim2_shared->scope_vmap_count,  rdim2_shared->scope_vmap_keys,  rdim2_shared->scope_vmap_keys__swap},
-      {rdim2_shared->unit_vmap_count,   rdim2_shared->unit_vmap_keys,   rdim2_shared->unit_vmap_keys__swap},
-      {rdim2_shared->global_vmap_count, rdim2_shared->global_vmap_keys, rdim2_shared->global_vmap_keys__swap},
+      {rdim_shared->scope_vmap_count,  rdim_shared->scope_vmap_keys,  rdim_shared->scope_vmap_keys__swap},
+      {rdim_shared->unit_vmap_count,   rdim_shared->unit_vmap_keys,   rdim_shared->unit_vmap_keys__swap},
+      {rdim_shared->global_vmap_count, rdim_shared->global_vmap_keys, rdim_shared->global_vmap_keys__swap},
     };
     for EachElement(sort_task_idx, sort_tasks) ProfScope("sort %I64u", sort_task_idx)
     {
@@ -273,8 +273,8 @@ rdim2_bake(Arena *arena, RDIM_BakeParams *params)
       U64 bits_per_digit = 8;
       U64 digits_count = 64 / bits_per_digit;
       U64 num_possible_values_per_digit = 1 << bits_per_digit;
-      rdim2_shared->lane_digit_counts[lane_idx()] = push_array_no_zero(arena, U32, num_possible_values_per_digit);
-      rdim2_shared->lane_digit_offsets[lane_idx()] = push_array_no_zero(arena, U32, num_possible_values_per_digit);
+      rdim_shared->lane_digit_counts[lane_idx()] = push_array_no_zero(arena, U32, num_possible_values_per_digit);
+      rdim_shared->lane_digit_offsets[lane_idx()] = push_array_no_zero(arena, U32, num_possible_values_per_digit);
       RDIM_SortKey *src = keys;
       RDIM_SortKey *dst = keys__swap;
       U64 element_count = vmap_count;
@@ -282,7 +282,7 @@ rdim2_bake(Arena *arena, RDIM_BakeParams *params)
       {
         // rjf: count digit value occurrences per-lane
         {
-          U32 *digit_counts = rdim2_shared->lane_digit_counts[lane_idx()];
+          U32 *digit_counts = rdim_shared->lane_digit_counts[lane_idx()];
           MemoryZero(digit_counts, sizeof(digit_counts[0])*num_possible_values_per_digit);
           Rng1U64 range = lane_range(element_count);
           for EachInRange(idx, range)
@@ -302,8 +302,8 @@ rdim2_bake(Arena *arena, RDIM_BakeParams *params)
             U64 layout_off = 0;
             for EachIndex(lane_idx, lane_count())
             {
-              rdim2_shared->lane_digit_offsets[lane_idx][value_idx] = layout_off;
-              layout_off += rdim2_shared->lane_digit_counts[lane_idx][value_idx];
+              rdim_shared->lane_digit_offsets[lane_idx][value_idx] = layout_off;
+              layout_off += rdim_shared->lane_digit_counts[lane_idx][value_idx];
             }
           }
         }
@@ -318,9 +318,9 @@ rdim2_bake(Arena *arena, RDIM_BakeParams *params)
           {
             for EachIndex(lane_idx, lane_count())
             {
-              rdim2_shared->lane_digit_offsets[lane_idx][value_idx] += last_off;
+              rdim_shared->lane_digit_offsets[lane_idx][value_idx] += last_off;
             }
-            last_off = rdim2_shared->lane_digit_offsets[lane_count()-1][value_idx] + rdim2_shared->lane_digit_counts[lane_count()-1][value_idx];
+            last_off = rdim_shared->lane_digit_offsets[lane_count()-1][value_idx] + rdim_shared->lane_digit_counts[lane_count()-1][value_idx];
           }
           // NOTE(rjf): required that: (last_off == element_count)
         }
@@ -328,7 +328,7 @@ rdim2_bake(Arena *arena, RDIM_BakeParams *params)
         
         // rjf: move
         {
-          U32 *lane_digit_offsets = rdim2_shared->lane_digit_offsets[lane_idx()];
+          U32 *lane_digit_offsets = rdim_shared->lane_digit_offsets[lane_idx()];
           Rng1U64 range = lane_range(element_count);
           for EachInRange(idx, range)
           {
@@ -374,30 +374,30 @@ rdim2_bake(Arena *arena, RDIM_BakeParams *params)
     {
       VMapBakeTask *task = push_array(scratch.arena, VMapBakeTask, 1);
       task->name          = str8_lit("scopes");
-      task->count         = rdim2_shared->scope_vmap_count;
-      task->keys          = rdim2_shared->scope_vmap_keys;
-      task->markers       = rdim2_shared->scope_vmap_markers;
-      task->bake_vmap_out = &rdim2_shared->baked_scope_vmap.vmap;
+      task->count         = rdim_shared->scope_vmap_count;
+      task->keys          = rdim_shared->scope_vmap_keys;
+      task->markers       = rdim_shared->scope_vmap_markers;
+      task->bake_vmap_out = &rdim_shared->baked_scope_vmap.vmap;
       SLLQueuePush(first_task, last_task, task);
     }
     if(lane_idx() == lane_from_task_idx(1))
     {
       VMapBakeTask *task = push_array(scratch.arena, VMapBakeTask, 1);
       task->name          = str8_lit("units");
-      task->count         = rdim2_shared->unit_vmap_count;
-      task->keys          = rdim2_shared->unit_vmap_keys;
-      task->markers       = rdim2_shared->unit_vmap_markers;
-      task->bake_vmap_out = &rdim2_shared->baked_unit_vmap.vmap;
+      task->count         = rdim_shared->unit_vmap_count;
+      task->keys          = rdim_shared->unit_vmap_keys;
+      task->markers       = rdim_shared->unit_vmap_markers;
+      task->bake_vmap_out = &rdim_shared->baked_unit_vmap.vmap;
       SLLQueuePush(first_task, last_task, task);
     }
     if(lane_idx() == lane_from_task_idx(2))
     {
       VMapBakeTask *task = push_array(scratch.arena, VMapBakeTask, 1);
       task->name          = str8_lit("globals");
-      task->count         = rdim2_shared->global_vmap_count;
-      task->keys          = rdim2_shared->global_vmap_keys;
-      task->markers       = rdim2_shared->global_vmap_markers;
-      task->bake_vmap_out = &rdim2_shared->baked_global_vmap.vmap;
+      task->count         = rdim_shared->global_vmap_count;
+      task->keys          = rdim_shared->global_vmap_keys;
+      task->markers       = rdim_shared->global_vmap_markers;
+      task->bake_vmap_out = &rdim_shared->baked_global_vmap.vmap;
       SLLQueuePush(first_task, last_task, task);
     }
     for(VMapBakeTask *task = first_task; task != 0; task = task->next) ProfScope("vmap bake for %.*s", str8_varg(task->name))
@@ -574,10 +574,10 @@ rdim2_bake(Arena *arena, RDIM_BakeParams *params)
       }
     }
     
-    rdim2_shared->path_tree = tree;
+    rdim_shared->path_tree = tree;
   }
   lane_sync();
-  RDIM_BakePathTree *path_tree = rdim2_shared->path_tree;
+  RDIM_BakePathTree *path_tree = rdim_shared->path_tree;
   
   //////////////////////////////////////////////////////////////
   //- rjf: @rdim_bake_stage gather all unsorted, joined, line table info; & sort
@@ -590,8 +590,8 @@ rdim2_bake(Arena *arena, RDIM_BakeParams *params)
       // rjf: calculate header info
       if(lane_idx() == 0)
       {
-        rdim2_shared->line_tables_count = params->line_tables.total_count;
-        rdim2_shared->src_line_tables = push_array(arena, RDIM_LineTable *, rdim2_shared->line_tables_count);
+        rdim_shared->line_tables_count = params->line_tables.total_count;
+        rdim_shared->src_line_tables = push_array(arena, RDIM_LineTable *, rdim_shared->line_tables_count);
         ProfScope("flatten chunk list")
         {
           U64 joined_idx = 0;
@@ -599,16 +599,16 @@ rdim2_bake(Arena *arena, RDIM_BakeParams *params)
           {
             for EachIndex(idx, n->count)
             {
-              rdim2_shared->src_line_tables[joined_idx] = &n->v[idx];
+              rdim_shared->src_line_tables[joined_idx] = &n->v[idx];
               joined_idx += 1;
             }
           }
         }
-        rdim2_shared->baked_line_tables.line_tables_count       = params->line_tables.total_count + 1;
-        rdim2_shared->baked_line_tables.line_table_voffs_count  = params->line_tables.total_line_count + 2*params->line_tables.total_seq_count;
-        rdim2_shared->baked_line_tables.line_table_lines_count  = params->line_tables.total_line_count + params->line_tables.total_seq_count;
-        rdim2_shared->baked_line_tables.line_table_columns_count= 1;
-        rdim2_shared->line_table_block_take_counter = 0;
+        rdim_shared->baked_line_tables.line_tables_count       = params->line_tables.total_count + 1;
+        rdim_shared->baked_line_tables.line_table_voffs_count  = params->line_tables.total_line_count + 2*params->line_tables.total_seq_count;
+        rdim_shared->baked_line_tables.line_table_lines_count  = params->line_tables.total_line_count + params->line_tables.total_seq_count;
+        rdim_shared->baked_line_tables.line_table_columns_count= 1;
+        rdim_shared->line_table_block_take_counter = 0;
       }
       lane_sync();
       
@@ -617,25 +617,25 @@ rdim2_bake(Arena *arena, RDIM_BakeParams *params)
       {
         if(lane_idx() == lane_from_task_idx(0))
         {
-          rdim2_shared->unsorted_joined_line_tables = push_array(arena, RDIM_UnsortedJoinedLineTable, rdim2_shared->line_tables_count);
+          rdim_shared->unsorted_joined_line_tables = push_array(arena, RDIM_UnsortedJoinedLineTable, rdim_shared->line_tables_count);
         }
         if(lane_idx() == lane_from_task_idx(1))
         {
-          rdim2_shared->sorted_line_table_keys = push_array(arena, RDIM_SortKey *, rdim2_shared->line_tables_count);
+          rdim_shared->sorted_line_table_keys = push_array(arena, RDIM_SortKey *, rdim_shared->line_tables_count);
         }
         if(lane_idx() == lane_from_task_idx(2))
         {
-          rdim2_shared->baked_line_tables.line_tables = push_array(arena, RDI_LineTable, rdim2_shared->baked_line_tables.line_tables_count);
+          rdim_shared->baked_line_tables.line_tables = push_array(arena, RDI_LineTable, rdim_shared->baked_line_tables.line_tables_count);
           ProfScope("lay out line tables")
           {
             U64 voffs_base_idx = 0;
             U64 lines_base_idx = 0;
             U64 cols_base_idx = 0;
-            for EachIndex(idx, rdim2_shared->line_tables_count)
+            for EachIndex(idx, rdim_shared->line_tables_count)
             {
               U64 final_idx = idx+1; // NOTE(rjf): +1, to reserve [0] for nil
-              RDIM_LineTable *src = rdim2_shared->src_line_tables[idx];
-              RDI_LineTable *dst = &rdim2_shared->baked_line_tables.line_tables[final_idx];
+              RDIM_LineTable *src = rdim_shared->src_line_tables[idx];
+              RDI_LineTable *dst = &rdim_shared->baked_line_tables.line_tables[final_idx];
               dst->voffs_base_idx = voffs_base_idx; // TODO(rjf): @u64_to_u32
               dst->lines_base_idx = lines_base_idx; // TODO(rjf): @u64_to_u32
               dst->cols_base_idx  = cols_base_idx; // TODO(rjf): @u64_to_u32
@@ -647,15 +647,15 @@ rdim2_bake(Arena *arena, RDIM_BakeParams *params)
         }
         if(lane_idx() == lane_from_task_idx(3))
         {
-          rdim2_shared->baked_line_tables.line_table_voffs   = push_array(arena, RDI_U64,       rdim2_shared->baked_line_tables.line_table_voffs_count);
+          rdim_shared->baked_line_tables.line_table_voffs   = push_array(arena, RDI_U64,       rdim_shared->baked_line_tables.line_table_voffs_count);
         }
         if(lane_idx() == lane_from_task_idx(4))
         {
-          rdim2_shared->baked_line_tables.line_table_lines   = push_array(arena, RDI_Line,      rdim2_shared->baked_line_tables.line_table_lines_count);
+          rdim_shared->baked_line_tables.line_table_lines   = push_array(arena, RDI_Line,      rdim_shared->baked_line_tables.line_table_lines_count);
         }
         if(lane_idx() == lane_from_task_idx(5))
         {
-          rdim2_shared->baked_line_tables.line_table_columns = push_array(arena, RDI_Column,    rdim2_shared->baked_line_tables.line_table_columns_count);
+          rdim_shared->baked_line_tables.line_table_columns = push_array(arena, RDI_Column,    rdim_shared->baked_line_tables.line_table_columns_count);
         }
       }
     }
@@ -665,21 +665,21 @@ rdim2_bake(Arena *arena, RDIM_BakeParams *params)
     ProfScope("wide bake") 
     {
       U64 line_table_block_size = 4096;
-      U64 line_table_block_count = (rdim2_shared->line_tables_count + line_table_block_size - 1) / line_table_block_size;
+      U64 line_table_block_count = (rdim_shared->line_tables_count + line_table_block_size - 1) / line_table_block_size;
       for(;;)
       {
-        U64 line_table_block_num = ins_atomic_u64_inc_eval(&rdim2_shared->line_table_block_take_counter);
+        U64 line_table_block_num = ins_atomic_u64_inc_eval(&rdim_shared->line_table_block_take_counter);
         if(0 == line_table_block_num || line_table_block_count < line_table_block_num)
         {
           break;
         }
         U64 line_table_block_idx = line_table_block_num-1;
         Rng1U64 line_table_range = r1u64(line_table_block_idx*line_table_block_size, (line_table_block_idx+1)*line_table_block_size);
-        line_table_range.max = Min(rdim2_shared->line_tables_count, line_table_range.max);
+        line_table_range.max = Min(rdim_shared->line_tables_count, line_table_range.max);
         for EachInRange(line_table_idx, line_table_range)
         {
-          RDIM_LineTable *src = rdim2_shared->src_line_tables[line_table_idx];
-          RDIM_UnsortedJoinedLineTable *dst = &rdim2_shared->unsorted_joined_line_tables[line_table_idx];
+          RDIM_LineTable *src = rdim_shared->src_line_tables[line_table_idx];
+          RDIM_UnsortedJoinedLineTable *dst = &rdim_shared->unsorted_joined_line_tables[line_table_idx];
           
           //- rjf: gather
           dst->line_count = src->line_count;
@@ -714,17 +714,17 @@ rdim2_bake(Arena *arena, RDIM_BakeParams *params)
           }
           
           //- rjf: sort
-          rdim2_shared->sorted_line_table_keys[line_table_idx] = rdim_sort_key_array(arena,
-                                                                                     rdim2_shared->unsorted_joined_line_tables[line_table_idx].line_keys,
-                                                                                     rdim2_shared->unsorted_joined_line_tables[line_table_idx].key_count);
+          rdim_shared->sorted_line_table_keys[line_table_idx] = rdim_sort_key_array(arena,
+                                                                                    rdim_shared->unsorted_joined_line_tables[line_table_idx].line_keys,
+                                                                                    rdim_shared->unsorted_joined_line_tables[line_table_idx].key_count);
           
           //- rjf: fill
-          RDIM_SortKey *sorted_line_keys = rdim2_shared->sorted_line_table_keys[line_table_idx];
-          U64 sorted_line_keys_count = rdim2_shared->unsorted_joined_line_tables[line_table_idx].key_count;
-          RDI_LineTable *dst_line_table = &rdim2_shared->baked_line_tables.line_tables[line_table_idx+1];
-          U64 *arranged_voffs           = rdim2_shared->baked_line_tables.line_table_voffs   + dst_line_table->voffs_base_idx;
-          RDI_Line *arranged_lines      = rdim2_shared->baked_line_tables.line_table_lines   + dst_line_table->lines_base_idx;
-          RDI_Column *arranged_cols     = rdim2_shared->baked_line_tables.line_table_columns + dst_line_table->cols_base_idx;
+          RDIM_SortKey *sorted_line_keys = rdim_shared->sorted_line_table_keys[line_table_idx];
+          U64 sorted_line_keys_count = rdim_shared->unsorted_joined_line_tables[line_table_idx].key_count;
+          RDI_LineTable *dst_line_table = &rdim_shared->baked_line_tables.line_tables[line_table_idx+1];
+          U64 *arranged_voffs           = rdim_shared->baked_line_tables.line_table_voffs   + dst_line_table->voffs_base_idx;
+          RDI_Line *arranged_lines      = rdim_shared->baked_line_tables.line_table_lines   + dst_line_table->lines_base_idx;
+          RDI_Column *arranged_cols     = rdim_shared->baked_line_tables.line_table_columns + dst_line_table->cols_base_idx;
           {
             for EachIndex(idx, sorted_line_keys_count)
             {
@@ -751,10 +751,10 @@ rdim2_bake(Arena *arena, RDIM_BakeParams *params)
     }
   }
   lane_sync();
-  RDI_U64 line_tables_count = rdim2_shared->line_tables_count;
-  RDIM_LineTable **src_line_tables = rdim2_shared->src_line_tables;
-  RDIM_UnsortedJoinedLineTable *unsorted_joined_line_tables = rdim2_shared->unsorted_joined_line_tables;
-  RDIM_SortKey **sorted_line_table_keys = rdim2_shared->sorted_line_table_keys;
+  RDI_U64 line_tables_count = rdim_shared->line_tables_count;
+  RDIM_LineTable **src_line_tables = rdim_shared->src_line_tables;
+  RDIM_UnsortedJoinedLineTable *unsorted_joined_line_tables = rdim_shared->unsorted_joined_line_tables;
+  RDIM_SortKey **sorted_line_table_keys = rdim_shared->sorted_line_table_keys;
   
   //////////////////////////////////////////////////////////////
   //- rjf: @rdim_bake_stage build string map
@@ -764,23 +764,23 @@ rdim2_bake(Arena *arena, RDIM_BakeParams *params)
     //- rjf: set up per-lane outputs
     if(lane_idx() == 0) ProfScope("set up per-lane outputs")
     {
-      rdim2_shared->bake_string_map_topology.slots_count = (64 +
-                                                            params->procedures.total_count*1 +
-                                                            params->global_variables.total_count*1 +
-                                                            params->thread_variables.total_count*1 +
-                                                            params->types.total_count/2);
-      rdim2_shared->lane_bake_string_maps__loose = push_array(arena, RDIM_BakeStringMapLoose *, lane_count());
-      rdim2_shared->bake_string_map__loose = rdim_bake_string_map_loose_make(arena, &rdim2_shared->bake_string_map_topology);
+      rdim_shared->bake_string_map_topology.slots_count = (64 +
+                                                           params->procedures.total_count*1 +
+                                                           params->global_variables.total_count*1 +
+                                                           params->thread_variables.total_count*1 +
+                                                           params->types.total_count/2);
+      rdim_shared->lane_bake_string_maps__loose = push_array(arena, RDIM_BakeStringMapLoose *, lane_count());
+      rdim_shared->bake_string_map__loose = rdim_bake_string_map_loose_make(arena, &rdim_shared->bake_string_map_topology);
     }
     lane_sync();
     
     //- rjf: set up this lane's map
     ProfScope("set up this lane's map")
     {
-      rdim2_shared->lane_bake_string_maps__loose[lane_idx()] = rdim_bake_string_map_loose_make(arena, &rdim2_shared->bake_string_map_topology);
+      rdim_shared->lane_bake_string_maps__loose[lane_idx()] = rdim_bake_string_map_loose_make(arena, &rdim_shared->bake_string_map_topology);
     }
-    RDIM_BakeStringMapTopology *lane_map_top = &rdim2_shared->bake_string_map_topology;
-    RDIM_BakeStringMapLoose *lane_map = rdim2_shared->lane_bake_string_maps__loose[lane_idx()];
+    RDIM_BakeStringMapTopology *lane_map_top = &rdim_shared->bake_string_map_topology;
+    RDIM_BakeStringMapLoose *lane_map = rdim_shared->lane_bake_string_maps__loose[lane_idx()];
     
     //- rjf: push all strings into this lane's map
     ProfScope("push all strings into this lane's map")
@@ -923,13 +923,13 @@ rdim2_bake(Arena *arena, RDIM_BakeParams *params)
     //- rjf: join
     ProfScope("join")
     {
-      Rng1U64 slot_range = lane_range(rdim2_shared->bake_string_map_topology.slots_count);
+      Rng1U64 slot_range = lane_range(rdim_shared->bake_string_map_topology.slots_count);
       for EachInRange(slot_idx, slot_range)
       {
         for EachIndex(src_lane_idx, lane_count())
         {
-          RDIM_BakeStringMapLoose *src_map = rdim2_shared->lane_bake_string_maps__loose[src_lane_idx];
-          RDIM_BakeStringMapLoose *dst_map = rdim2_shared->bake_string_map__loose;
+          RDIM_BakeStringMapLoose *src_map = rdim_shared->lane_bake_string_maps__loose[src_lane_idx];
+          RDIM_BakeStringMapLoose *dst_map = rdim_shared->bake_string_map__loose;
           if(dst_map->slots[slot_idx] == 0 && src_map->slots[slot_idx] != 0)
           {
             dst_map->slots[slot_idx] = src_map->slots[slot_idx];
@@ -946,8 +946,8 @@ rdim2_bake(Arena *arena, RDIM_BakeParams *params)
     //- rjf: sort
     ProfScope("sort")
     {
-      RDIM_BakeStringMapLoose *map = rdim2_shared->bake_string_map__loose;
-      Rng1U64 slot_range = lane_range(rdim2_shared->bake_string_map_topology.slots_count);
+      RDIM_BakeStringMapLoose *map = rdim_shared->bake_string_map__loose;
+      Rng1U64 slot_range = lane_range(rdim_shared->bake_string_map_topology.slots_count);
       for EachInRange(slot_idx, slot_range)
       {
         if(map->slots[slot_idx] != 0 && map->slots[slot_idx]->total_count > 1)
@@ -961,32 +961,32 @@ rdim2_bake(Arena *arena, RDIM_BakeParams *params)
     //- rjf: tighten string table
     ProfScope("tighten string table")
     {
-      RDIM_BakeStringMapLoose *map = rdim2_shared->bake_string_map__loose;
-      RDIM_BakeStringMapTopology *map_top = &rdim2_shared->bake_string_map_topology;
+      RDIM_BakeStringMapLoose *map = rdim_shared->bake_string_map__loose;
+      RDIM_BakeStringMapTopology *map_top = &rdim_shared->bake_string_map_topology;
       if(lane_idx() == 0) ProfScope("calc base indices, set up tight map")
       {
         RDIM_BakeStringMapBaseIndices bake_string_map_base_indices = rdim_bake_string_map_base_indices_from_map_loose(arena, map_top, map);
-        rdim2_shared->bake_strings.slots_count = map_top->slots_count;
-        rdim2_shared->bake_strings.slots = rdim_push_array(arena, RDIM_BakeStringChunkList, rdim2_shared->bake_strings.slots_count);
-        rdim2_shared->bake_strings.slots_base_idxs = bake_string_map_base_indices.slots_base_idxs;
-        rdim2_shared->bake_strings.total_count = rdim2_shared->bake_strings.slots_base_idxs[rdim2_shared->bake_strings.slots_count];
+        rdim_shared->bake_strings.slots_count = map_top->slots_count;
+        rdim_shared->bake_strings.slots = rdim_push_array(arena, RDIM_BakeStringChunkList, rdim_shared->bake_strings.slots_count);
+        rdim_shared->bake_strings.slots_base_idxs = bake_string_map_base_indices.slots_base_idxs;
+        rdim_shared->bake_strings.total_count = rdim_shared->bake_strings.slots_base_idxs[rdim_shared->bake_strings.slots_count];
       }
       lane_sync();
       ProfScope("fill tight map")
       {
-        Rng1U64 slot_range = lane_range(rdim2_shared->bake_strings.slots_count);
+        Rng1U64 slot_range = lane_range(rdim_shared->bake_strings.slots_count);
         for EachInRange(idx, slot_range)
         {
           if(map->slots[idx] != 0)
           {
-            rdim_memcpy_struct(&rdim2_shared->bake_strings.slots[idx], map->slots[idx]);
+            rdim_memcpy_struct(&rdim_shared->bake_strings.slots[idx], map->slots[idx]);
           }
         }
       }
     }
   }
   lane_sync();
-  RDIM_BakeStringMapTight *bake_strings = &rdim2_shared->bake_strings;
+  RDIM_BakeStringMapTight *bake_strings = &rdim_shared->bake_strings;
   
   //////////////////////////////////////////////////////////////
   //- rjf: @rdim_bake_stage build name maps
@@ -1014,8 +1014,8 @@ rdim2_bake(Arena *arena, RDIM_BakeParams *params)
           Case(NormalSourcePaths, params->src_files.total_count);
 #undef Case
         }
-        rdim2_shared->lane_bake_name_maps[k] = push_array(arena, RDIM_BakeNameMap *, lane_count());
-        rdim2_shared->bake_name_map_topology[k].slots_count = slot_count;
+        rdim_shared->lane_bake_name_maps[k] = push_array(arena, RDIM_BakeNameMap *, lane_count());
+        rdim_shared->bake_name_map_topology[k].slots_count = slot_count;
       }
     }
     lane_sync();
@@ -1023,9 +1023,9 @@ rdim2_bake(Arena *arena, RDIM_BakeParams *params)
     //- rjf: wide build
     for EachNonZeroEnumVal(RDI_NameMapKind, k) ProfScope("name map build %.*s", str8_varg(rdi_string_from_name_map_kind(k)))
     {
-      RDIM_BakeNameMapTopology *top = &rdim2_shared->bake_name_map_topology[k];
-      rdim2_shared->lane_bake_name_maps[k][lane_idx()] = rdim_bake_name_map_make(arena, top);
-      RDIM_BakeNameMap *map = rdim2_shared->lane_bake_name_maps[k][lane_idx()];
+      RDIM_BakeNameMapTopology *top = &rdim_shared->bake_name_map_topology[k];
+      rdim_shared->lane_bake_name_maps[k][lane_idx()] = rdim_bake_name_map_make(arena, top);
+      RDIM_BakeNameMap *map = rdim_shared->lane_bake_name_maps[k][lane_idx()];
       B32 link_names = 0;
       RDIM_SymbolChunkList *symbols = 0;
       switch((RDI_NameMapKindEnum)k)
@@ -1086,14 +1086,14 @@ rdim2_bake(Arena *arena, RDIM_BakeParams *params)
     {
       for EachNonZeroEnumVal(RDI_NameMapKind, k)
       {
-        rdim2_shared->bake_name_maps[k] = rdim_bake_name_map_make(arena, &rdim2_shared->bake_name_map_topology[k]);
+        rdim_shared->bake_name_maps[k] = rdim_bake_name_map_make(arena, &rdim_shared->bake_name_map_topology[k]);
       }
     }
     lane_sync();
     for EachNonZeroEnumVal(RDI_NameMapKind, k) ProfScope("name map join & sort %.*s", str8_varg(rdi_string_from_name_map_kind(k)))
     {
-      RDIM_BakeNameMapTopology *top = &rdim2_shared->bake_name_map_topology[k];
-      RDIM_BakeNameMap *map = rdim2_shared->bake_name_maps[k];
+      RDIM_BakeNameMapTopology *top = &rdim_shared->bake_name_map_topology[k];
+      RDIM_BakeNameMap *map = rdim_shared->bake_name_maps[k];
       
       //- rjf: join
       ProfScope("join")
@@ -1103,7 +1103,7 @@ rdim2_bake(Arena *arena, RDIM_BakeParams *params)
         {
           for EachIndex(src_lane_idx, lane_count())
           {
-            RDIM_BakeNameMap *src_map = rdim2_shared->lane_bake_name_maps[k][src_lane_idx];
+            RDIM_BakeNameMap *src_map = rdim_shared->lane_bake_name_maps[k][src_lane_idx];
             RDIM_BakeNameMap *dst_map = map;
             if(dst_map->slots[slot_idx] == 0 && src_map->slots[slot_idx] != 0)
             {
@@ -1141,23 +1141,23 @@ rdim2_bake(Arena *arena, RDIM_BakeParams *params)
     //- rjf: set up per-lane outputs
     if(lane_idx() == 0) ProfScope("set up per-lane outputs")
     {
-      rdim2_shared->bake_idx_run_map_topology.slots_count = (64 +
-                                                             params->procedures.total_count +
-                                                             params->global_variables.total_count +
-                                                             params->thread_variables.total_count +
-                                                             params->types.total_count);
-      rdim2_shared->lane_bake_idx_run_maps__loose = push_array(arena, RDIM_BakeIdxRunMapLoose *, lane_count());
-      rdim2_shared->bake_idx_run_map__loose = rdim_bake_idx_run_map_loose_make(arena, &rdim2_shared->bake_idx_run_map_topology);
+      rdim_shared->bake_idx_run_map_topology.slots_count = (64 +
+                                                            params->procedures.total_count +
+                                                            params->global_variables.total_count +
+                                                            params->thread_variables.total_count +
+                                                            params->types.total_count);
+      rdim_shared->lane_bake_idx_run_maps__loose = push_array(arena, RDIM_BakeIdxRunMapLoose *, lane_count());
+      rdim_shared->bake_idx_run_map__loose = rdim_bake_idx_run_map_loose_make(arena, &rdim_shared->bake_idx_run_map_topology);
     }
     lane_sync();
     
     //- rjf: set up this lane's map
     ProfScope("set up this lane's map")
     {
-      rdim2_shared->lane_bake_idx_run_maps__loose[lane_idx()] = rdim_bake_idx_run_map_loose_make(arena, &rdim2_shared->bake_idx_run_map_topology);
+      rdim_shared->lane_bake_idx_run_maps__loose[lane_idx()] = rdim_bake_idx_run_map_loose_make(arena, &rdim_shared->bake_idx_run_map_topology);
     }
-    RDIM_BakeIdxRunMapTopology *lane_map_top = &rdim2_shared->bake_idx_run_map_topology;
-    RDIM_BakeIdxRunMapLoose *lane_map = rdim2_shared->lane_bake_idx_run_maps__loose[lane_idx()];
+    RDIM_BakeIdxRunMapTopology *lane_map_top = &rdim_shared->bake_idx_run_map_topology;
+    RDIM_BakeIdxRunMapLoose *lane_map = rdim_shared->lane_bake_idx_run_maps__loose[lane_idx()];
     
     //- rjf: wide fill of all index runs
     ProfScope("fill all lane index run maps")
@@ -1192,8 +1192,8 @@ rdim2_bake(Arena *arena, RDIM_BakeParams *params)
       //- rjf: bake runs of name map match lists
       for EachNonZeroEnumVal(RDI_NameMapKind, k) ProfScope("bake runs of name map match lists (%.*s)", str8_varg(rdi_string_from_name_map_kind(k)))
       {
-        RDIM_BakeNameMapTopology *top = &rdim2_shared->bake_name_map_topology[k];
-        RDIM_BakeNameMap *map = rdim2_shared->bake_name_maps[k];
+        RDIM_BakeNameMapTopology *top = &rdim_shared->bake_name_map_topology[k];
+        RDIM_BakeNameMap *map = rdim_shared->bake_name_maps[k];
         Rng1U64 slot_idx_range = lane_range(top->slots_count);
         for EachInRange(slot_idx, slot_idx_range)
         {
@@ -1283,13 +1283,13 @@ rdim2_bake(Arena *arena, RDIM_BakeParams *params)
     //- rjf: join
     ProfScope("join")
     {
-      Rng1U64 slot_range = lane_range(rdim2_shared->bake_idx_run_map_topology.slots_count);
+      Rng1U64 slot_range = lane_range(rdim_shared->bake_idx_run_map_topology.slots_count);
       for EachInRange(slot_idx, slot_range)
       {
         for EachIndex(src_lane_idx, lane_count())
         {
-          RDIM_BakeIdxRunMapLoose *src_map = rdim2_shared->lane_bake_idx_run_maps__loose[src_lane_idx];
-          RDIM_BakeIdxRunMapLoose *dst_map = rdim2_shared->bake_idx_run_map__loose;
+          RDIM_BakeIdxRunMapLoose *src_map = rdim_shared->lane_bake_idx_run_maps__loose[src_lane_idx];
+          RDIM_BakeIdxRunMapLoose *dst_map = rdim_shared->bake_idx_run_map__loose;
           dst_map->slots_idx_counts[slot_idx] += src_map->slots_idx_counts[slot_idx];
           if(dst_map->slots[slot_idx] == 0 && src_map->slots[slot_idx] != 0)
           {
@@ -1307,8 +1307,8 @@ rdim2_bake(Arena *arena, RDIM_BakeParams *params)
     //- rjf: sort
     ProfScope("sort")
     {
-      RDIM_BakeIdxRunMapLoose *map = rdim2_shared->bake_idx_run_map__loose;
-      Rng1U64 slot_range = lane_range(rdim2_shared->bake_idx_run_map_topology.slots_count);
+      RDIM_BakeIdxRunMapLoose *map = rdim_shared->bake_idx_run_map__loose;
+      Rng1U64 slot_range = lane_range(rdim_shared->bake_idx_run_map_topology.slots_count);
       for EachInRange(slot_idx, slot_range)
       {
         if(map->slots[slot_idx] != 0 && map->slots[slot_idx]->total_count > 1)
@@ -1330,40 +1330,40 @@ rdim2_bake(Arena *arena, RDIM_BakeParams *params)
     //- rjf: tighten idx run table
     ProfScope("tighten idx run table")
     {
-      RDIM_BakeIdxRunMapLoose *map = rdim2_shared->bake_idx_run_map__loose;
-      RDIM_BakeIdxRunMapTopology *map_top = &rdim2_shared->bake_idx_run_map_topology;
+      RDIM_BakeIdxRunMapLoose *map = rdim_shared->bake_idx_run_map__loose;
+      RDIM_BakeIdxRunMapTopology *map_top = &rdim_shared->bake_idx_run_map_topology;
       if(lane_idx() == 0) ProfScope("calc base indices, set up tight map")
       {
-        rdim2_shared->bake_idx_runs.slots_count = map_top->slots_count;
-        rdim2_shared->bake_idx_runs.slots = rdim_push_array(arena, RDIM_BakeIdxRunChunkList, rdim2_shared->bake_idx_runs.slots_count);
-        rdim2_shared->bake_idx_runs.slots_base_idxs = rdim_push_array(arena, RDI_U64, rdim2_shared->bake_idx_runs.slots_count+1);
+        rdim_shared->bake_idx_runs.slots_count = map_top->slots_count;
+        rdim_shared->bake_idx_runs.slots = rdim_push_array(arena, RDIM_BakeIdxRunChunkList, rdim_shared->bake_idx_runs.slots_count);
+        rdim_shared->bake_idx_runs.slots_base_idxs = rdim_push_array(arena, RDI_U64, rdim_shared->bake_idx_runs.slots_count+1);
         RDI_U64 encoding_idx_off = 0;
         for(RDI_U64 slot_idx = 0; slot_idx < map_top->slots_count; slot_idx += 1)
         {
-          rdim2_shared->bake_idx_runs.slots_base_idxs[slot_idx] = encoding_idx_off;
+          rdim_shared->bake_idx_runs.slots_base_idxs[slot_idx] = encoding_idx_off;
           if(map->slots[slot_idx] != 0)
           {
             encoding_idx_off += map->slots_idx_counts[slot_idx];
           }
         }
-        rdim2_shared->bake_idx_runs.slots_base_idxs[map_top->slots_count] = encoding_idx_off;
+        rdim_shared->bake_idx_runs.slots_base_idxs[map_top->slots_count] = encoding_idx_off;
       }
       lane_sync();
       ProfScope("fill tight map")
       {
-        Rng1U64 slot_range = lane_range(rdim2_shared->bake_idx_runs.slots_count);
+        Rng1U64 slot_range = lane_range(rdim_shared->bake_idx_runs.slots_count);
         for EachInRange(idx, slot_range)
         {
           if(map->slots[idx] != 0)
           {
-            rdim_memcpy_struct(&rdim2_shared->bake_idx_runs.slots[idx], map->slots[idx]);
+            rdim_memcpy_struct(&rdim_shared->bake_idx_runs.slots[idx], map->slots[idx]);
           }
         }
       }
     }
   }
   lane_sync();
-  RDIM_BakeIdxRunMap *bake_idx_runs = &rdim2_shared->bake_idx_runs;
+  RDIM_BakeIdxRunMap *bake_idx_runs = &rdim_shared->bake_idx_runs;
   
   //////////////////////////////////////////////////////////////
   //- rjf: @rdim_bake_stage bake strings
@@ -1373,8 +1373,8 @@ rdim2_bake(Arena *arena, RDIM_BakeParams *params)
     // rjf: set up 
     if(lane_idx() == 0) ProfScope("set up; lay out strings")
     {
-      rdim2_shared->baked_strings.string_offs_count = bake_strings->total_count + 1;
-      rdim2_shared->baked_strings.string_offs = rdim_push_array(arena, RDI_U32, rdim2_shared->baked_strings.string_offs_count);
+      rdim_shared->baked_strings.string_offs_count = bake_strings->total_count + 1;
+      rdim_shared->baked_strings.string_offs = rdim_push_array(arena, RDI_U32, rdim_shared->baked_strings.string_offs_count);
       RDI_U64 off_cursor = 0;
       for EachIndex(slot_idx, bake_strings->slots_count)
       {
@@ -1384,13 +1384,13 @@ rdim2_bake(Arena *arena, RDIM_BakeParams *params)
           {
             RDIM_BakeString *src = &n->v[n_idx];
             U64 dst_idx = bake_strings->slots_base_idxs[slot_idx] + n->base_idx + n_idx + 1;
-            rdim2_shared->baked_strings.string_offs[dst_idx] = off_cursor;
+            rdim_shared->baked_strings.string_offs[dst_idx] = off_cursor;
             off_cursor += src->string.size;
           }
         }
       }
-      rdim2_shared->baked_strings.string_data_size = off_cursor;
-      rdim2_shared->baked_strings.string_data = rdim_push_array(arena, RDI_U8, rdim2_shared->baked_strings.string_data_size);
+      rdim_shared->baked_strings.string_data_size = off_cursor;
+      rdim_shared->baked_strings.string_data = rdim_push_array(arena, RDI_U8, rdim_shared->baked_strings.string_data_size);
     }
     lane_sync();
     
@@ -1406,15 +1406,15 @@ rdim2_bake(Arena *arena, RDIM_BakeParams *params)
           {
             RDIM_BakeString *src = &n->v[n_idx];
             U64 dst_idx = bake_strings->slots_base_idxs[slot_idx] + n->base_idx + n_idx + 1;
-            U64 dst_off = rdim2_shared->baked_strings.string_offs[dst_idx];
-            rdim_memcpy(rdim2_shared->baked_strings.string_data + dst_off, src->string.str, src->string.size);
+            U64 dst_off = rdim_shared->baked_strings.string_offs[dst_idx];
+            rdim_memcpy(rdim_shared->baked_strings.string_data + dst_off, src->string.str, src->string.size);
           }
         }
       }
     }
   }
   lane_sync();
-  RDIM_StringBakeResult baked_strings = rdim2_shared->baked_strings;
+  RDIM_StringBakeResult baked_strings = rdim_shared->baked_strings;
   
   //////////////////////////////////////////////////////////////
   //- rjf: @rdim_bake_stage bake idx runs
@@ -1424,8 +1424,8 @@ rdim2_bake(Arena *arena, RDIM_BakeParams *params)
     // rjf: set up
     if(lane_idx() == 0)
     {
-      rdim2_shared->baked_idx_runs.idx_count = bake_idx_runs->slots_base_idxs[bake_idx_runs->slots_count];
-      rdim2_shared->baked_idx_runs.idx_runs = push_array(arena, RDI_U32, rdim2_shared->baked_idx_runs.idx_count);
+      rdim_shared->baked_idx_runs.idx_count = bake_idx_runs->slots_base_idxs[bake_idx_runs->slots_count];
+      rdim_shared->baked_idx_runs.idx_runs = push_array(arena, RDI_U32, rdim_shared->baked_idx_runs.idx_count);
     }
     lane_sync();
     
@@ -1437,10 +1437,10 @@ rdim2_bake(Arena *arena, RDIM_BakeParams *params)
         RDI_U64 off = bake_idx_runs->slots_base_idxs[slot_idx];
         for EachNode(n, RDIM_BakeIdxRunChunkNode, bake_idx_runs->slots[slot_idx].first)
         {
-          StaticAssert(sizeof(rdim2_shared->baked_idx_runs.idx_runs[0]) == sizeof(n->v[0].idxes[0]), idx_run_size_check);
+          StaticAssert(sizeof(rdim_shared->baked_idx_runs.idx_runs[0]) == sizeof(n->v[0].idxes[0]), idx_run_size_check);
           for EachIndex(n_idx, n->count)
           {
-            rdim_memcpy(rdim2_shared->baked_idx_runs.idx_runs + off, n->v[n_idx].idxes, sizeof(n->v[n_idx].idxes[0]) * n->v[n_idx].count);
+            rdim_memcpy(rdim_shared->baked_idx_runs.idx_runs + off, n->v[n_idx].idxes, sizeof(n->v[n_idx].idxes[0]) * n->v[n_idx].count);
             off += n->v[n_idx].count;
           }
         }
@@ -1448,7 +1448,7 @@ rdim2_bake(Arena *arena, RDIM_BakeParams *params)
     }
   }
   lane_sync();
-  RDIM_IndexRunBakeResult baked_idx_runs = rdim2_shared->baked_idx_runs;
+  RDIM_IndexRunBakeResult baked_idx_runs = rdim_shared->baked_idx_runs;
   
   //////////////////////////////////////////////////////////////
   //- rjf: @rdim_bake_stage bake name maps
@@ -1462,15 +1462,15 @@ rdim2_bake(Arena *arena, RDIM_BakeParams *params)
       {
         for EachNonZeroEnumVal(RDI_NameMapKind, k)
         {
-          rdim2_shared->lane_name_map_node_counts[k] = push_array(arena, U64, lane_count());
-          rdim2_shared->lane_name_map_node_offs[k] = push_array(arena, U64, lane_count());
+          rdim_shared->lane_name_map_node_counts[k] = push_array(arena, U64, lane_count());
+          rdim_shared->lane_name_map_node_offs[k] = push_array(arena, U64, lane_count());
         }
       }
       lane_sync();
       for EachNonZeroEnumVal(RDI_NameMapKind, k)
       {
-        RDIM_BakeNameMapTopology *top = &rdim2_shared->bake_name_map_topology[k];
-        RDIM_BakeNameMap *map = rdim2_shared->bake_name_maps[k];
+        RDIM_BakeNameMapTopology *top = &rdim_shared->bake_name_map_topology[k];
+        RDIM_BakeNameMap *map = rdim_shared->bake_name_maps[k];
         Rng1U64 range = lane_range(top->slots_count);
         for EachInRange(idx, range)
         {
@@ -1489,7 +1489,7 @@ rdim2_bake(Arena *arena, RDIM_BakeParams *params)
                 }
               }
             }
-            rdim2_shared->lane_name_map_node_counts[k][lane_idx()] += total_unique_name_count;
+            rdim_shared->lane_name_map_node_counts[k][lane_idx()] += total_unique_name_count;
           }
         }
       }
@@ -1501,11 +1501,11 @@ rdim2_bake(Arena *arena, RDIM_BakeParams *params)
           RDI_U64 node_off = 0;
           for EachIndex(l_idx, lane_count())
           {
-            rdim2_shared->name_map_node_counts[k] += rdim2_shared->lane_name_map_node_counts[k][l_idx];
-            rdim2_shared->lane_name_map_node_offs[k][l_idx] = node_off;
-            node_off += rdim2_shared->lane_name_map_node_counts[k][l_idx];
+            rdim_shared->name_map_node_counts[k] += rdim_shared->lane_name_map_node_counts[k][l_idx];
+            rdim_shared->lane_name_map_node_offs[k][l_idx] = node_off;
+            node_off += rdim_shared->lane_name_map_node_counts[k][l_idx];
           }
-          rdim2_shared->total_name_map_node_count += rdim2_shared->name_map_node_counts[k];
+          rdim_shared->total_name_map_node_count += rdim_shared->name_map_node_counts[k];
         }
       }
     }
@@ -1516,26 +1516,26 @@ rdim2_bake(Arena *arena, RDIM_BakeParams *params)
     {
       if(lane_idx() == lane_from_task_idx(0))
       {
-        rdim2_shared->baked_top_level_name_maps.name_maps_count = RDI_NameMapKind_COUNT;
-        rdim2_shared->baked_top_level_name_maps.name_maps = push_array(arena, RDI_NameMap, rdim2_shared->baked_top_level_name_maps.name_maps_count);
+        rdim_shared->baked_top_level_name_maps.name_maps_count = RDI_NameMapKind_COUNT;
+        rdim_shared->baked_top_level_name_maps.name_maps = push_array(arena, RDI_NameMap, rdim_shared->baked_top_level_name_maps.name_maps_count);
         RDI_U32 bucket_off = 0;
         RDI_U32 node_off = 0;
         for EachNonZeroEnumVal(RDI_NameMapKind, k)
         {
-          rdim2_shared->baked_top_level_name_maps.name_maps[k].bucket_base_idx = bucket_off;
-          rdim2_shared->baked_top_level_name_maps.name_maps[k].node_base_idx = node_off;
-          rdim2_shared->baked_top_level_name_maps.name_maps[k].bucket_count = (RDI_U32)rdim2_shared->bake_name_map_topology[k].slots_count; // TODO(rjf): @u64_to_u32
-          rdim2_shared->baked_top_level_name_maps.name_maps[k].node_count = (RDI_U32)rdim2_shared->name_map_node_counts[k]; // TODO(rjf): @u64_to_u32
-          bucket_off += rdim2_shared->baked_top_level_name_maps.name_maps[k].bucket_count;
-          node_off += rdim2_shared->baked_top_level_name_maps.name_maps[k].node_count;
+          rdim_shared->baked_top_level_name_maps.name_maps[k].bucket_base_idx = bucket_off;
+          rdim_shared->baked_top_level_name_maps.name_maps[k].node_base_idx = node_off;
+          rdim_shared->baked_top_level_name_maps.name_maps[k].bucket_count = (RDI_U32)rdim_shared->bake_name_map_topology[k].slots_count; // TODO(rjf): @u64_to_u32
+          rdim_shared->baked_top_level_name_maps.name_maps[k].node_count = (RDI_U32)rdim_shared->name_map_node_counts[k]; // TODO(rjf): @u64_to_u32
+          bucket_off += rdim_shared->baked_top_level_name_maps.name_maps[k].bucket_count;
+          node_off += rdim_shared->baked_top_level_name_maps.name_maps[k].node_count;
         }
-        rdim2_shared->baked_name_maps.buckets_count = bucket_off;
-        rdim2_shared->baked_name_maps.buckets = push_array(arena, RDI_NameMapBucket, rdim2_shared->baked_name_maps.buckets_count);
+        rdim_shared->baked_name_maps.buckets_count = bucket_off;
+        rdim_shared->baked_name_maps.buckets = push_array(arena, RDI_NameMapBucket, rdim_shared->baked_name_maps.buckets_count);
       }
       if(lane_idx() == lane_from_task_idx(1))
       {
-        rdim2_shared->baked_name_maps.nodes_count = rdim2_shared->total_name_map_node_count;
-        rdim2_shared->baked_name_maps.nodes = push_array(arena, RDI_NameMapNode, rdim2_shared->baked_name_maps.nodes_count);
+        rdim_shared->baked_name_maps.nodes_count = rdim_shared->total_name_map_node_count;
+        rdim_shared->baked_name_maps.nodes = push_array(arena, RDI_NameMapNode, rdim_shared->baked_name_maps.nodes_count);
       }
     }
     lane_sync();
@@ -1545,13 +1545,13 @@ rdim2_bake(Arena *arena, RDIM_BakeParams *params)
     {
       for EachNonZeroEnumVal(RDI_NameMapKind, k) ProfScope("wide fill (%.*s)", str8_varg(rdi_string_from_name_map_kind(k)))
       {
-        RDI_U64 write_node_off = rdim2_shared->lane_name_map_node_offs[k][lane_idx()];
-        RDIM_BakeNameMapTopology *top = &rdim2_shared->bake_name_map_topology[k];
+        RDI_U64 write_node_off = rdim_shared->lane_name_map_node_offs[k][lane_idx()];
+        RDIM_BakeNameMapTopology *top = &rdim_shared->bake_name_map_topology[k];
         U64 slots_count = top->slots_count;
-        RDIM_BakeNameMap *src_map = rdim2_shared->bake_name_maps[k];
-        RDI_NameMap *dst_map = &rdim2_shared->baked_top_level_name_maps.name_maps[k];
-        RDI_NameMapBucket *dst_buckets = rdim2_shared->baked_name_maps.buckets + dst_map->bucket_base_idx;
-        RDI_NameMapNode *dst_nodes = rdim2_shared->baked_name_maps.nodes + dst_map->node_base_idx;
+        RDIM_BakeNameMap *src_map = rdim_shared->bake_name_maps[k];
+        RDI_NameMap *dst_map = &rdim_shared->baked_top_level_name_maps.name_maps[k];
+        RDI_NameMapBucket *dst_buckets = rdim_shared->baked_name_maps.buckets + dst_map->bucket_base_idx;
+        RDI_NameMapNode *dst_nodes = rdim_shared->baked_name_maps.nodes + dst_map->node_base_idx;
         Rng1U64 slot_range = lane_range(slots_count);
         for EachInRange(slot_idx, slot_range)
         {
@@ -1666,7 +1666,7 @@ rdim2_bake(Arena *arena, RDIM_BakeParams *params)
   {
     if(lane_idx() == 0)
     {
-      rdim2_shared->bake_src_line_maps = push_array(arena, RDIM_BakeSrcLineMap, params->src_files.total_count);
+      rdim_shared->bake_src_line_maps = push_array(arena, RDIM_BakeSrcLineMap, params->src_files.total_count);
     }
     lane_sync();
     {
@@ -1676,7 +1676,7 @@ rdim2_bake(Arena *arena, RDIM_BakeParams *params)
         for EachInRange(n_idx, range)
         {
           U64 file_idx = n->base_idx + n_idx;
-          RDIM_BakeSrcLineMap *map = &rdim2_shared->bake_src_line_maps[file_idx];
+          RDIM_BakeSrcLineMap *map = &rdim_shared->bake_src_line_maps[file_idx];
           
           // rjf: set up map
           map->slots_count = n->v[n_idx].total_line_count;
@@ -1735,22 +1735,22 @@ rdim2_bake(Arena *arena, RDIM_BakeParams *params)
     U64 map_count = params->src_files.total_count;
     if(lane_idx() == 0)
     {
-      rdim2_shared->bake_src_line_map_keys = push_array(arena, RDIM_SortKey *, map_count);
+      rdim_shared->bake_src_line_map_keys = push_array(arena, RDIM_SortKey *, map_count);
     }
     lane_sync();
     for(;;)
     {
-      U64 map_num = ins_atomic_u64_inc_eval(&rdim2_shared->bake_src_line_map_take_counter);
+      U64 map_num = ins_atomic_u64_inc_eval(&rdim_shared->bake_src_line_map_take_counter);
       if(map_num < 1 || map_count < map_num)
       {
         break;
       }
       U64 map_idx = map_num-1;
-      RDIM_BakeSrcLineMap *map = &rdim2_shared->bake_src_line_maps[map_idx];
+      RDIM_BakeSrcLineMap *map = &rdim_shared->bake_src_line_maps[map_idx];
       
       // rjf: gather keys
-      rdim2_shared->bake_src_line_map_keys[map_idx] = push_array_no_zero(arena, RDIM_SortKey, map->line_count);
-      RDIM_SortKey *keys = rdim2_shared->bake_src_line_map_keys[map_idx];
+      rdim_shared->bake_src_line_map_keys[map_idx] = push_array_no_zero(arena, RDIM_SortKey, map->line_count);
+      RDIM_SortKey *keys = rdim_shared->bake_src_line_map_keys[map_idx];
       {
         U64 key_idx = 0;
         for EachIndex(slot_idx, map->slots_count)
@@ -1779,12 +1779,12 @@ rdim2_bake(Arena *arena, RDIM_BakeParams *params)
     // rjf: set up
     if(lane_idx() == 0)
     {
-      rdim2_shared->lane_chunk_src_file_num_counts  = push_array(arena, U64, lane_count()*params->src_files.chunk_count);
-      rdim2_shared->lane_chunk_src_file_voff_counts = push_array(arena, U64, lane_count()*params->src_files.chunk_count);
-      rdim2_shared->lane_chunk_src_file_map_counts  = push_array(arena, U64, lane_count()*params->src_files.chunk_count);
-      rdim2_shared->lane_chunk_src_file_num_offs    = push_array(arena, U64, lane_count()*params->src_files.chunk_count);
-      rdim2_shared->lane_chunk_src_file_voff_offs   = push_array(arena, U64, lane_count()*params->src_files.chunk_count);
-      rdim2_shared->lane_chunk_src_file_map_offs    = push_array(arena, U64, lane_count()*params->src_files.chunk_count);
+      rdim_shared->lane_chunk_src_file_num_counts  = push_array(arena, U64, lane_count()*params->src_files.chunk_count);
+      rdim_shared->lane_chunk_src_file_voff_counts = push_array(arena, U64, lane_count()*params->src_files.chunk_count);
+      rdim_shared->lane_chunk_src_file_map_counts  = push_array(arena, U64, lane_count()*params->src_files.chunk_count);
+      rdim_shared->lane_chunk_src_file_num_offs    = push_array(arena, U64, lane_count()*params->src_files.chunk_count);
+      rdim_shared->lane_chunk_src_file_voff_offs   = push_array(arena, U64, lane_count()*params->src_files.chunk_count);
+      rdim_shared->lane_chunk_src_file_map_offs    = push_array(arena, U64, lane_count()*params->src_files.chunk_count);
     }
     lane_sync();
     
@@ -1797,10 +1797,10 @@ rdim2_bake(Arena *arena, RDIM_BakeParams *params)
         U64 slot_idx = lane_idx()*params->src_files.chunk_count + chunk_idx;
         for EachInRange(idx, range)
         {
-          RDIM_BakeSrcLineMap *map = &rdim2_shared->bake_src_line_maps[n->base_idx + idx];
-          rdim2_shared->lane_chunk_src_file_num_counts[slot_idx] += map->line_count;
-          rdim2_shared->lane_chunk_src_file_voff_counts[slot_idx] += map->voff_range_count;
-          rdim2_shared->lane_chunk_src_file_map_counts[slot_idx] += !!map->line_count;
+          RDIM_BakeSrcLineMap *map = &rdim_shared->bake_src_line_maps[n->base_idx + idx];
+          rdim_shared->lane_chunk_src_file_num_counts[slot_idx] += map->line_count;
+          rdim_shared->lane_chunk_src_file_voff_counts[slot_idx] += map->voff_range_count;
+          rdim_shared->lane_chunk_src_file_map_counts[slot_idx] += !!map->line_count;
         }
         chunk_idx += 1;
       }
@@ -1819,17 +1819,17 @@ rdim2_bake(Arena *arena, RDIM_BakeParams *params)
         for EachIndex(l_idx, lane_count())
         {
           U64 slot_idx = l_idx*params->src_files.chunk_count + chunk_idx;
-          rdim2_shared->lane_chunk_src_file_num_offs[slot_idx] = num_layout_off;
-          rdim2_shared->lane_chunk_src_file_voff_offs[slot_idx] = voff_layout_off;
-          rdim2_shared->lane_chunk_src_file_map_offs[slot_idx] = map_layout_off;
-          num_layout_off += rdim2_shared->lane_chunk_src_file_num_counts[slot_idx];
-          voff_layout_off += rdim2_shared->lane_chunk_src_file_voff_counts[slot_idx];
-          map_layout_off += rdim2_shared->lane_chunk_src_file_map_counts[slot_idx];
+          rdim_shared->lane_chunk_src_file_num_offs[slot_idx] = num_layout_off;
+          rdim_shared->lane_chunk_src_file_voff_offs[slot_idx] = voff_layout_off;
+          rdim_shared->lane_chunk_src_file_map_offs[slot_idx] = map_layout_off;
+          num_layout_off += rdim_shared->lane_chunk_src_file_num_counts[slot_idx];
+          voff_layout_off += rdim_shared->lane_chunk_src_file_voff_counts[slot_idx];
+          map_layout_off += rdim_shared->lane_chunk_src_file_map_counts[slot_idx];
         }
         chunk_idx += 1;
       }
-      rdim2_shared->total_src_map_line_count = num_layout_off;
-      rdim2_shared->total_src_map_voff_count = voff_layout_off;
+      rdim_shared->total_src_map_line_count = num_layout_off;
+      rdim_shared->total_src_map_voff_count = voff_layout_off;
     }
   }
   lane_sync();
@@ -1842,16 +1842,16 @@ rdim2_bake(Arena *arena, RDIM_BakeParams *params)
     //- rjf: set up
     if(lane_idx() == 0)
     {
-      rdim2_shared->baked_src_files.source_files_count = params->src_files.total_count+1;
-      rdim2_shared->baked_src_files.source_files = push_array(arena, RDI_SourceFile, rdim2_shared->baked_src_files.source_files_count);
-      rdim2_shared->baked_src_files.source_line_maps_count = params->src_files.source_line_map_count+1;
-      rdim2_shared->baked_src_files.source_line_maps = push_array(arena, RDI_SourceLineMap, rdim2_shared->baked_src_files.source_line_maps_count);
-      rdim2_shared->baked_src_files.source_line_map_nums_count = rdim2_shared->total_src_map_line_count;
-      rdim2_shared->baked_src_files.source_line_map_nums = push_array(arena, RDI_U32, rdim2_shared->baked_src_files.source_line_map_nums_count);
-      rdim2_shared->baked_src_files.source_line_map_rngs_count = rdim2_shared->total_src_map_line_count + rdim2_shared->baked_src_files.source_line_maps_count;
-      rdim2_shared->baked_src_files.source_line_map_rngs = push_array(arena, RDI_U32, rdim2_shared->baked_src_files.source_line_map_rngs_count);
-      rdim2_shared->baked_src_files.source_line_map_voffs_count = rdim2_shared->total_src_map_voff_count;
-      rdim2_shared->baked_src_files.source_line_map_voffs = push_array(arena, RDI_U64, rdim2_shared->baked_src_files.source_line_map_voffs_count);
+      rdim_shared->baked_src_files.source_files_count = params->src_files.total_count+1;
+      rdim_shared->baked_src_files.source_files = push_array(arena, RDI_SourceFile, rdim_shared->baked_src_files.source_files_count);
+      rdim_shared->baked_src_files.source_line_maps_count = params->src_files.source_line_map_count+1;
+      rdim_shared->baked_src_files.source_line_maps = push_array(arena, RDI_SourceLineMap, rdim_shared->baked_src_files.source_line_maps_count);
+      rdim_shared->baked_src_files.source_line_map_nums_count = rdim_shared->total_src_map_line_count;
+      rdim_shared->baked_src_files.source_line_map_nums = push_array(arena, RDI_U32, rdim_shared->baked_src_files.source_line_map_nums_count);
+      rdim_shared->baked_src_files.source_line_map_rngs_count = rdim_shared->total_src_map_line_count + rdim_shared->baked_src_files.source_line_maps_count;
+      rdim_shared->baked_src_files.source_line_map_rngs = push_array(arena, RDI_U32, rdim_shared->baked_src_files.source_line_map_rngs_count);
+      rdim_shared->baked_src_files.source_line_map_voffs_count = rdim_shared->total_src_map_voff_count;
+      rdim_shared->baked_src_files.source_line_map_voffs = push_array(arena, RDI_U64, rdim_shared->baked_src_files.source_line_map_voffs_count);
     }
     lane_sync();
     
@@ -1861,20 +1861,20 @@ rdim2_bake(Arena *arena, RDIM_BakeParams *params)
     {
       Rng1U64 range = lane_range(n->count);
       U64 slot_idx = lane_idx()*params->src_files.chunk_count + chunk_idx;
-      U64 dst_num_off  = rdim2_shared->lane_chunk_src_file_num_offs[slot_idx];
-      U64 dst_map_off  = rdim2_shared->lane_chunk_src_file_map_offs[slot_idx];
-      U64 dst_voff_off = rdim2_shared->lane_chunk_src_file_voff_offs[slot_idx];
+      U64 dst_num_off  = rdim_shared->lane_chunk_src_file_num_offs[slot_idx];
+      U64 dst_map_off  = rdim_shared->lane_chunk_src_file_map_offs[slot_idx];
+      U64 dst_voff_off = rdim_shared->lane_chunk_src_file_voff_offs[slot_idx];
       U64 dst_rng_off  = dst_num_off + dst_map_off;
       for EachInRange(idx, range)
       {
-        RDIM_BakeSrcLineMap *map = &rdim2_shared->bake_src_line_maps[n->base_idx + idx];
-        RDIM_SortKey *sorted_map_keys = rdim2_shared->bake_src_line_map_keys[n->base_idx + idx];
+        RDIM_BakeSrcLineMap *map = &rdim_shared->bake_src_line_maps[n->base_idx + idx];
+        RDIM_SortKey *sorted_map_keys = rdim_shared->bake_src_line_map_keys[n->base_idx + idx];
         RDIM_SrcFile *src = &n->v[idx];
-        RDI_SourceFile *dst = &rdim2_shared->baked_src_files.source_files[n->base_idx + idx + 1];
-        RDI_SourceLineMap *dst_map = &rdim2_shared->baked_src_files.source_line_maps[dst_map_off];
-        RDI_U32 *dst_nums  = &rdim2_shared->baked_src_files.source_line_map_nums[dst_num_off];
-        RDI_U32 *dst_rngs  = &rdim2_shared->baked_src_files.source_line_map_rngs[dst_rng_off];
-        RDI_U64 *dst_voffs = &rdim2_shared->baked_src_files.source_line_map_voffs[dst_voff_off];
+        RDI_SourceFile *dst = &rdim_shared->baked_src_files.source_files[n->base_idx + idx + 1];
+        RDI_SourceLineMap *dst_map = &rdim_shared->baked_src_files.source_line_maps[dst_map_off];
+        RDI_U32 *dst_nums  = &rdim_shared->baked_src_files.source_line_map_nums[dst_num_off];
+        RDI_U32 *dst_rngs  = &rdim_shared->baked_src_files.source_line_map_rngs[dst_rng_off];
+        RDI_U64 *dst_voffs = &rdim_shared->baked_src_files.source_line_map_voffs[dst_voff_off];
         
         //- rjf: fill file info
         Temp scratch = scratch_begin(&arena, 1);
@@ -1928,10 +1928,10 @@ rdim2_bake(Arena *arena, RDIM_BakeParams *params)
     // rjf: allocate
     if(lane_idx() == 0)
     {
-      rdim2_shared->member_chunk_lane_counts = push_array(arena, U64, lane_count() * params->udts.chunk_count);
-      rdim2_shared->member_chunk_lane_offs = push_array(arena, U64, lane_count() * params->udts.chunk_count);
-      rdim2_shared->enum_val_chunk_lane_counts = push_array(arena, U64, lane_count() * params->udts.chunk_count);
-      rdim2_shared->enum_val_chunk_lane_offs = push_array(arena, U64, lane_count() * params->udts.chunk_count);
+      rdim_shared->member_chunk_lane_counts = push_array(arena, U64, lane_count() * params->udts.chunk_count);
+      rdim_shared->member_chunk_lane_offs = push_array(arena, U64, lane_count() * params->udts.chunk_count);
+      rdim_shared->enum_val_chunk_lane_counts = push_array(arena, U64, lane_count() * params->udts.chunk_count);
+      rdim_shared->enum_val_chunk_lane_offs = push_array(arena, U64, lane_count() * params->udts.chunk_count);
     }
     lane_sync();
     
@@ -1944,8 +1944,8 @@ rdim2_bake(Arena *arena, RDIM_BakeParams *params)
         for EachInRange(idx, range)
         {
           U64 slot_idx = lane_idx()*params->udts.chunk_count + chunk_idx;
-          rdim2_shared->member_chunk_lane_counts[slot_idx] += n->v[idx].member_count;
-          rdim2_shared->enum_val_chunk_lane_counts[slot_idx] += n->v[idx].enum_val_count;
+          rdim_shared->member_chunk_lane_counts[slot_idx] += n->v[idx].member_count;
+          rdim_shared->enum_val_chunk_lane_counts[slot_idx] += n->v[idx].enum_val_count;
         }
         chunk_idx += 1;
       }
@@ -1963,10 +1963,10 @@ rdim2_bake(Arena *arena, RDIM_BakeParams *params)
         for EachIndex(l_idx, lane_count())
         {
           U64 slot_idx = l_idx*params->udts.chunk_count + chunk_idx;
-          rdim2_shared->member_chunk_lane_offs[slot_idx] = member_layout_off;
-          rdim2_shared->enum_val_chunk_lane_offs[slot_idx] = enum_val_layout_off;
-          member_layout_off += rdim2_shared->member_chunk_lane_counts[slot_idx];
-          enum_val_layout_off += rdim2_shared->enum_val_chunk_lane_counts[slot_idx];
+          rdim_shared->member_chunk_lane_offs[slot_idx] = member_layout_off;
+          rdim_shared->enum_val_chunk_lane_offs[slot_idx] = enum_val_layout_off;
+          member_layout_off += rdim_shared->member_chunk_lane_counts[slot_idx];
+          enum_val_layout_off += rdim_shared->enum_val_chunk_lane_counts[slot_idx];
         }
         chunk_idx += 1;
       }
@@ -1984,18 +1984,18 @@ rdim2_bake(Arena *arena, RDIM_BakeParams *params)
     {
       if(lane_idx() == lane_from_task_idx(0))
       {
-        rdim2_shared->baked_udts.udts_count = params->udts.total_count+1;
-        rdim2_shared->baked_udts.udts = push_array(arena, RDI_UDT, rdim2_shared->baked_udts.udts_count);
+        rdim_shared->baked_udts.udts_count = params->udts.total_count+1;
+        rdim_shared->baked_udts.udts = push_array(arena, RDI_UDT, rdim_shared->baked_udts.udts_count);
       }
       if(lane_idx() == lane_from_task_idx(1))
       {
-        rdim2_shared->baked_udts.members_count = params->udts.total_member_count+1;
-        rdim2_shared->baked_udts.members = push_array(arena, RDI_Member, rdim2_shared->baked_udts.members_count);
+        rdim_shared->baked_udts.members_count = params->udts.total_member_count+1;
+        rdim_shared->baked_udts.members = push_array(arena, RDI_Member, rdim_shared->baked_udts.members_count);
       }
       if(lane_idx() == lane_from_task_idx(2))
       {
-        rdim2_shared->baked_udts.enum_members_count = params->udts.total_enum_val_count+1;
-        rdim2_shared->baked_udts.enum_members = push_array(arena, RDI_EnumMember, rdim2_shared->baked_udts.enum_members_count);
+        rdim_shared->baked_udts.enum_members_count = params->udts.total_enum_val_count+1;
+        rdim_shared->baked_udts.enum_members = push_array(arena, RDI_EnumMember, rdim_shared->baked_udts.enum_members_count);
       }
     }
     lane_sync();
@@ -2008,12 +2008,12 @@ rdim2_bake(Arena *arena, RDIM_BakeParams *params)
       {
         Rng1U64 range = lane_range(n->count);
         U64 layout_slot_idx = lane_idx()*params->udts.chunk_count + chunk_idx;
-        U64 member_layout_off = rdim2_shared->member_chunk_lane_offs[layout_slot_idx];
-        U64 enum_val_layout_off = rdim2_shared->enum_val_chunk_lane_offs[layout_slot_idx];
+        U64 member_layout_off = rdim_shared->member_chunk_lane_offs[layout_slot_idx];
+        U64 enum_val_layout_off = rdim_shared->enum_val_chunk_lane_offs[layout_slot_idx];
         for EachInRange(n_idx, range)
         {
           RDIM_UDT *src_udt = &n->v[n_idx];
-          RDI_UDT *dst_udt = &rdim2_shared->baked_udts.udts[n->base_idx + n_idx + 1];
+          RDI_UDT *dst_udt = &rdim_shared->baked_udts.udts[n->base_idx + n_idx + 1];
           
           //- rjf: fill basics
           dst_udt->self_type_idx = (RDI_U32)rdim_idx_from_type(src_udt->self_type); // TODO(rjf): @u64_to_u32
@@ -2027,7 +2027,7 @@ rdim2_bake(Arena *arena, RDIM_BakeParams *params)
             U64 member_off_first = member_layout_off;
             for EachNode(src_member, RDIM_UDTMember, src_udt->first_member)
             {
-              RDI_Member *dst_member = &rdim2_shared->baked_udts.members[member_layout_off];
+              RDI_Member *dst_member = &rdim_shared->baked_udts.members[member_layout_off];
               dst_member->kind            = src_member->kind;
               dst_member->name_string_idx = rdim_bake_idx_from_string(bake_strings, src_member->name);
               dst_member->type_idx        = (RDI_U32)rdim_idx_from_type(src_member->type); // TODO(rjf): @u64_to_u32
@@ -2045,7 +2045,7 @@ rdim2_bake(Arena *arena, RDIM_BakeParams *params)
             U64 enum_val_off_first = enum_val_layout_off;
             for EachNode(src_enum_val, RDIM_UDTEnumVal, src_udt->first_enum_val)
             {
-              RDI_EnumMember *dst_member = &rdim2_shared->baked_udts.enum_members[enum_val_layout_off];
+              RDI_EnumMember *dst_member = &rdim_shared->baked_udts.enum_members[enum_val_layout_off];
               dst_member->name_string_idx = rdim_bake_idx_from_string(bake_strings, src_enum_val->name);
               dst_member->val             = src_enum_val->val;
               enum_val_layout_off += 1;
@@ -2071,8 +2071,8 @@ rdim2_bake(Arena *arena, RDIM_BakeParams *params)
     // rjf: set up
     if(lane_idx() == 0)
     {
-      rdim2_shared->location_case_chunk_lane_counts = push_array(arena, RDI_U64, lane_count() * total_location_case_chunk_count);
-      rdim2_shared->location_case_chunk_lane_offs = push_array(arena, RDI_U64, lane_count() * total_location_case_chunk_count);
+      rdim_shared->location_case_chunk_lane_counts = push_array(arena, RDI_U64, lane_count() * total_location_case_chunk_count);
+      rdim_shared->location_case_chunk_lane_offs = push_array(arena, RDI_U64, lane_count() * total_location_case_chunk_count);
     }
     lane_sync();
     
@@ -2088,7 +2088,7 @@ rdim2_bake(Arena *arena, RDIM_BakeParams *params)
         {
           for EachNode(local, RDIM_Local, n->v[idx].first_local)
           {
-            rdim2_shared->location_case_chunk_lane_counts[slot_idx] += local->location_cases.count;
+            rdim_shared->location_case_chunk_lane_counts[slot_idx] += local->location_cases.count;
           }
         }
         chunk_idx += 1;
@@ -2101,7 +2101,7 @@ rdim2_bake(Arena *arena, RDIM_BakeParams *params)
         Rng1U64 range = lane_range(n->count);
         for EachInRange(idx, range)
         {
-          rdim2_shared->location_case_chunk_lane_counts[slot_idx] += n->v[idx].location_cases.count;
+          rdim_shared->location_case_chunk_lane_counts[slot_idx] += n->v[idx].location_cases.count;
         }
         chunk_idx += 1;
       }
@@ -2118,8 +2118,8 @@ rdim2_bake(Arena *arena, RDIM_BakeParams *params)
         for EachIndex(l_idx, lane_count())
         {
           U64 slot_idx = l_idx * total_location_case_chunk_count + chunk_idx;
-          rdim2_shared->location_case_chunk_lane_offs[slot_idx] = location_case_layout_off;
-          location_case_layout_off += rdim2_shared->location_case_chunk_lane_counts[slot_idx];
+          rdim_shared->location_case_chunk_lane_offs[slot_idx] = location_case_layout_off;
+          location_case_layout_off += rdim_shared->location_case_chunk_lane_counts[slot_idx];
         }
         chunk_idx += 1;
       }
@@ -2128,12 +2128,12 @@ rdim2_bake(Arena *arena, RDIM_BakeParams *params)
         for EachIndex(l_idx, lane_count())
         {
           U64 slot_idx = l_idx * total_location_case_chunk_count + chunk_idx;
-          rdim2_shared->location_case_chunk_lane_offs[slot_idx] = location_case_layout_off;
-          location_case_layout_off += rdim2_shared->location_case_chunk_lane_counts[slot_idx];
+          rdim_shared->location_case_chunk_lane_offs[slot_idx] = location_case_layout_off;
+          location_case_layout_off += rdim_shared->location_case_chunk_lane_counts[slot_idx];
         }
         chunk_idx += 1;
       }
-      rdim2_shared->total_location_case_count = location_case_layout_off;
+      rdim_shared->total_location_case_count = location_case_layout_off;
     }
   }
   lane_sync();
@@ -2146,8 +2146,8 @@ rdim2_bake(Arena *arena, RDIM_BakeParams *params)
     // rjf: set up
     if(lane_idx() == 0)
     {
-      rdim2_shared->baked_location_blocks.location_blocks_count = rdim2_shared->total_location_case_count;
-      rdim2_shared->baked_location_blocks.location_blocks = push_array(arena, RDI_LocationBlock, rdim2_shared->baked_location_blocks.location_blocks_count);
+      rdim_shared->baked_location_blocks.location_blocks_count = rdim_shared->total_location_case_count;
+      rdim_shared->baked_location_blocks.location_blocks = push_array(arena, RDI_LocationBlock, rdim_shared->baked_location_blocks.location_blocks_count);
     }
     lane_sync();
     
@@ -2158,7 +2158,7 @@ rdim2_bake(Arena *arena, RDIM_BakeParams *params)
       for EachNode(n, RDIM_ScopeChunkNode, params->scopes.first)
       {
         U64 layout_slot_idx = lane_idx() * total_location_case_chunk_count + chunk_idx;
-        U64 layout_off = rdim2_shared->location_case_chunk_lane_offs[layout_slot_idx];
+        U64 layout_off = rdim_shared->location_case_chunk_lane_offs[layout_slot_idx];
         Rng1U64 range = lane_range(n->count);
         for EachInRange(idx, range)
         {
@@ -2166,7 +2166,7 @@ rdim2_bake(Arena *arena, RDIM_BakeParams *params)
           {
             for EachNode(src, RDIM_LocationCase, local->location_cases.first)
             {
-              RDI_LocationBlock *dst = &rdim2_shared->baked_location_blocks.location_blocks[layout_off];
+              RDI_LocationBlock *dst = &rdim_shared->baked_location_blocks.location_blocks[layout_off];
               dst->scope_off_first   = (RDI_U32)src->voff_range.min; // TODO(rjf): @u64_to_u32
               dst->scope_off_opl     = (RDI_U32)src->voff_range.max; // TODO(rjf): @u64_to_u32
               dst->location_data_off = (RDI_U32)rdim_off_from_location(src->location); // TODO(rjf): @u64_to_u32
@@ -2184,13 +2184,13 @@ rdim2_bake(Arena *arena, RDIM_BakeParams *params)
       for EachNode(n, RDIM_SymbolChunkNode, params->procedures.first)
       {
         U64 layout_slot_idx = lane_idx() * total_location_case_chunk_count + chunk_idx;
-        U64 layout_off = rdim2_shared->location_case_chunk_lane_offs[layout_slot_idx];
+        U64 layout_off = rdim_shared->location_case_chunk_lane_offs[layout_slot_idx];
         Rng1U64 range = lane_range(n->count);
         for EachInRange(idx, range)
         {
           for EachNode(src, RDIM_LocationCase, n->v[idx].location_cases.first)
           {
-            RDI_LocationBlock *dst = &rdim2_shared->baked_location_blocks.location_blocks[layout_off];
+            RDI_LocationBlock *dst = &rdim_shared->baked_location_blocks.location_blocks[layout_off];
             dst->scope_off_first = (RDI_U32)src->voff_range.min; // TODO(rjf): @u64_to_u32
             dst->scope_off_opl   = (RDI_U32)src->voff_range.max; // TODO(rjf): @u64_to_u32
             dst->location_data_off = (RDI_U32)rdim_off_from_location(src->location); // TODO(rjf): @u64_to_u32
@@ -2209,8 +2209,8 @@ rdim2_bake(Arena *arena, RDIM_BakeParams *params)
   {
     if(lane_idx() == 0)
     {
-      rdim2_shared->baked_locations.location_data_size = params->locations.total_encoded_size+1;
-      rdim2_shared->baked_locations.location_data = push_array(arena, RDI_U8, rdim2_shared->baked_locations.location_data_size);
+      rdim_shared->baked_locations.location_data_size = params->locations.total_encoded_size+1;
+      rdim_shared->baked_locations.location_data = push_array(arena, RDI_U8, rdim_shared->baked_locations.location_data_size);
     }
     lane_sync();
     for EachNode(n, RDIM_LocationChunkNode, params->locations.first)
@@ -2219,7 +2219,7 @@ rdim2_bake(Arena *arena, RDIM_BakeParams *params)
       for EachInRange(n_idx, range)
       {
         RDIM_Location *loc = &n->v[n_idx];
-        RDI_U8 *dst = &rdim2_shared->baked_locations.location_data[n->base_encoding_off + loc->relative_encoding_off + 1];
+        RDI_U8 *dst = &rdim_shared->baked_locations.location_data[n->base_encoding_off + loc->relative_encoding_off + 1];
         switch((RDI_LocationKindEnum)loc->info.kind)
         {
           case RDI_LocationKind_NULL:{}break;
@@ -2261,10 +2261,10 @@ rdim2_bake(Arena *arena, RDIM_BakeParams *params)
     // rjf: set up
     if(lane_idx() == 0)
     {
-      rdim2_shared->scope_local_chunk_lane_counts = push_array(arena, RDI_U64, lane_count() * params->scopes.chunk_count);
-      rdim2_shared->scope_local_chunk_lane_offs = push_array(arena, RDI_U64, lane_count() * params->scopes.chunk_count);
-      rdim2_shared->scope_voff_chunk_lane_counts = push_array(arena, RDI_U64, lane_count() * params->scopes.chunk_count);
-      rdim2_shared->scope_voff_chunk_lane_offs = push_array(arena, RDI_U64, lane_count() * params->scopes.chunk_count);
+      rdim_shared->scope_local_chunk_lane_counts = push_array(arena, RDI_U64, lane_count() * params->scopes.chunk_count);
+      rdim_shared->scope_local_chunk_lane_offs = push_array(arena, RDI_U64, lane_count() * params->scopes.chunk_count);
+      rdim_shared->scope_voff_chunk_lane_counts = push_array(arena, RDI_U64, lane_count() * params->scopes.chunk_count);
+      rdim_shared->scope_voff_chunk_lane_offs = push_array(arena, RDI_U64, lane_count() * params->scopes.chunk_count);
     }
     lane_sync();
     
@@ -2281,8 +2281,8 @@ rdim2_bake(Arena *arena, RDIM_BakeParams *params)
           num_locals_in_this_lane_and_node += n->v[n_idx].local_count;
           num_voffs_in_this_lane_and_node += n->v[n_idx].voff_ranges.count*2;
         }
-        rdim2_shared->scope_local_chunk_lane_counts[lane_idx()*params->scopes.chunk_count + chunk_idx] = num_locals_in_this_lane_and_node;
-        rdim2_shared->scope_voff_chunk_lane_counts[lane_idx()*params->scopes.chunk_count + chunk_idx] = num_voffs_in_this_lane_and_node;
+        rdim_shared->scope_local_chunk_lane_counts[lane_idx()*params->scopes.chunk_count + chunk_idx] = num_locals_in_this_lane_and_node;
+        rdim_shared->scope_voff_chunk_lane_counts[lane_idx()*params->scopes.chunk_count + chunk_idx] = num_voffs_in_this_lane_and_node;
         chunk_idx += 1;
       }
     }
@@ -2299,10 +2299,10 @@ rdim2_bake(Arena *arena, RDIM_BakeParams *params)
         for EachIndex(l_idx, lane_count())
         {
           U64 slot_idx = l_idx*params->scopes.chunk_count + chunk_idx;
-          rdim2_shared->scope_local_chunk_lane_offs[slot_idx] = local_layout_off;
-          rdim2_shared->scope_voff_chunk_lane_offs[slot_idx] = voff_layout_off;
-          local_layout_off += rdim2_shared->scope_local_chunk_lane_counts[slot_idx];
-          voff_layout_off += rdim2_shared->scope_voff_chunk_lane_counts[slot_idx];
+          rdim_shared->scope_local_chunk_lane_offs[slot_idx] = local_layout_off;
+          rdim_shared->scope_voff_chunk_lane_offs[slot_idx] = voff_layout_off;
+          local_layout_off += rdim_shared->scope_local_chunk_lane_counts[slot_idx];
+          voff_layout_off += rdim_shared->scope_voff_chunk_lane_counts[slot_idx];
         }
         chunk_idx += 1;
       }
@@ -2319,18 +2319,18 @@ rdim2_bake(Arena *arena, RDIM_BakeParams *params)
     //- rjf: setup outputs
     if(lane_idx() == lane_from_task_idx(0))
     {
-      rdim2_shared->baked_scopes.scopes_count = params->scopes.total_count+1;
-      rdim2_shared->baked_scopes.scopes = push_array(arena, RDI_Scope, rdim2_shared->baked_scopes.scopes_count);
+      rdim_shared->baked_scopes.scopes_count = params->scopes.total_count+1;
+      rdim_shared->baked_scopes.scopes = push_array(arena, RDI_Scope, rdim_shared->baked_scopes.scopes_count);
     }
     if(lane_idx() == lane_from_task_idx(1))
     {
-      rdim2_shared->baked_scopes.scope_voffs_count = params->scopes.scope_voff_count+1;
-      rdim2_shared->baked_scopes.scope_voffs = push_array(arena, RDI_U64, rdim2_shared->baked_scopes.scope_voffs_count);
+      rdim_shared->baked_scopes.scope_voffs_count = params->scopes.scope_voff_count+1;
+      rdim_shared->baked_scopes.scope_voffs = push_array(arena, RDI_U64, rdim_shared->baked_scopes.scope_voffs_count);
     }
     if(lane_idx() == lane_from_task_idx(2))
     {
-      rdim2_shared->baked_scopes.locals_count = params->scopes.local_count+1;
-      rdim2_shared->baked_scopes.locals = push_array(arena, RDI_Local, rdim2_shared->baked_scopes.locals_count);
+      rdim_shared->baked_scopes.locals_count = params->scopes.local_count+1;
+      rdim_shared->baked_scopes.locals = push_array(arena, RDI_Local, rdim_shared->baked_scopes.locals_count);
     }
     lane_sync();
     
@@ -2341,22 +2341,22 @@ rdim2_bake(Arena *arena, RDIM_BakeParams *params)
       {
         Rng1U64 range = lane_range(n->count);
         U64 scope_chunk_lane_slot_idx = lane_idx()*params->scopes.chunk_count + chunk_idx;
-        U64 chunk_local_off = rdim2_shared->scope_local_chunk_lane_offs[scope_chunk_lane_slot_idx];
-        U64 chunk_voff_off = rdim2_shared->scope_voff_chunk_lane_offs[scope_chunk_lane_slot_idx];
+        U64 chunk_local_off = rdim_shared->scope_local_chunk_lane_offs[scope_chunk_lane_slot_idx];
+        U64 chunk_voff_off = rdim_shared->scope_voff_chunk_lane_offs[scope_chunk_lane_slot_idx];
         U64 location_block_chunk_lane_slot_idx = lane_idx() * total_location_case_chunk_count + chunk_idx;
-        U64 chunk_location_block_off = rdim2_shared->location_case_chunk_lane_offs[location_block_chunk_lane_slot_idx];
+        U64 chunk_location_block_off = rdim_shared->location_case_chunk_lane_offs[location_block_chunk_lane_slot_idx];
         for EachInRange(n_idx, range)
         {
           U64 dst_idx = 1 + n->base_idx + n_idx;
           RDIM_Scope *src_scope = &n->v[n_idx];
-          RDI_Scope *dst_scope = &rdim2_shared->baked_scopes.scopes[dst_idx];
+          RDI_Scope *dst_scope = &rdim_shared->baked_scopes.scopes[dst_idx];
           
           //- rjf: fill voff ranges
           U64 voff_idx_first = chunk_voff_off;
           for EachNode(rng_n, RDIM_Rng1U64Node, src_scope->voff_ranges.first)
           {
-            rdim2_shared->baked_scopes.scope_voffs[chunk_voff_off+0] = rng_n->v.min;
-            rdim2_shared->baked_scopes.scope_voffs[chunk_voff_off+1] = rng_n->v.max;
+            rdim_shared->baked_scopes.scope_voffs[chunk_voff_off+0] = rng_n->v.min;
+            rdim_shared->baked_scopes.scope_voffs[chunk_voff_off+1] = rng_n->v.max;
             chunk_voff_off += 2;
           }
           U64 voff_idx_opl = chunk_voff_off;
@@ -2365,7 +2365,7 @@ rdim2_bake(Arena *arena, RDIM_BakeParams *params)
           U64 local_idx_first = chunk_local_off;
           for EachNode(src_local, RDIM_Local, src_scope->first_local)
           {
-            RDI_Local *dst_local = &rdim2_shared->baked_scopes.locals[chunk_local_off];
+            RDI_Local *dst_local = &rdim_shared->baked_scopes.locals[chunk_local_off];
             dst_local->kind            = src_local->kind;
             dst_local->name_string_idx = rdim_bake_idx_from_string(bake_strings, src_local->name);
             dst_local->type_idx        = (RDI_U32)rdim_idx_from_type(src_local->type); // TODO(rjf): @u64_to_u32
@@ -2403,8 +2403,8 @@ rdim2_bake(Arena *arena, RDIM_BakeParams *params)
   {
     if(lane_idx() == 0)
     {
-      rdim2_shared->baked_procedures.procedures_count = params->procedures.total_count+1;
-      rdim2_shared->baked_procedures.procedures = push_array(arena, RDI_Procedure, rdim2_shared->baked_procedures.procedures_count);
+      rdim_shared->baked_procedures.procedures_count = params->procedures.total_count+1;
+      rdim_shared->baked_procedures.procedures = push_array(arena, RDI_Procedure, rdim_shared->baked_procedures.procedures_count);
     }
     lane_sync();
     {
@@ -2412,12 +2412,12 @@ rdim2_bake(Arena *arena, RDIM_BakeParams *params)
       for EachNode(n, RDIM_SymbolChunkNode, params->procedures.first)
       {
         U64 location_block_layout_slot_idx = lane_idx()*total_location_case_chunk_count + params->scopes.chunk_count + chunk_idx;
-        U64 location_block_off = rdim2_shared->location_case_chunk_lane_offs[location_block_layout_slot_idx];
+        U64 location_block_off = rdim_shared->location_case_chunk_lane_offs[location_block_layout_slot_idx];
         Rng1U64 range = lane_range(n->count);
         for EachInRange(n_idx, range)
         {
           RDIM_Symbol *src = &n->v[n_idx];
-          RDI_Procedure *dst = &rdim2_shared->baked_procedures.procedures[n->base_idx + n_idx + 1];
+          RDI_Procedure *dst = &rdim_shared->baked_procedures.procedures[n->base_idx + n_idx + 1];
           dst->name_string_idx      = rdim_bake_idx_from_string(bake_strings, src->name);
           dst->link_name_string_idx = rdim_bake_idx_from_string(bake_strings, src->link_name);
           if(src->is_extern)
@@ -2456,8 +2456,8 @@ rdim2_bake(Arena *arena, RDIM_BakeParams *params)
     // rjf: set up
     if(lane_idx() == 0)
     {
-      rdim2_shared->constant_data_chunk_lane_counts = push_array(arena, U64, lane_count() * params->constants.chunk_count);
-      rdim2_shared->constant_data_chunk_lane_offs = push_array(arena, U64, lane_count() * params->constants.chunk_count);
+      rdim_shared->constant_data_chunk_lane_counts = push_array(arena, U64, lane_count() * params->constants.chunk_count);
+      rdim_shared->constant_data_chunk_lane_offs = push_array(arena, U64, lane_count() * params->constants.chunk_count);
     }
     lane_sync();
     
@@ -2470,7 +2470,7 @@ rdim2_bake(Arena *arena, RDIM_BakeParams *params)
         Rng1U64 range = lane_range(n->count);
         for EachInRange(idx, range)
         {
-          rdim2_shared->constant_data_chunk_lane_counts[slot_idx] += n->v[idx].value_data.size;
+          rdim_shared->constant_data_chunk_lane_counts[slot_idx] += n->v[idx].value_data.size;
         }
         chunk_idx += 1;
       }
@@ -2487,8 +2487,8 @@ rdim2_bake(Arena *arena, RDIM_BakeParams *params)
         for EachIndex(l_idx, lane_count())
         {
           U64 slot_idx = l_idx*params->constants.chunk_count + chunk_idx;
-          rdim2_shared->constant_data_chunk_lane_offs[slot_idx] = layout_off;
-          layout_off += rdim2_shared->constant_data_chunk_lane_counts[slot_idx];
+          rdim_shared->constant_data_chunk_lane_offs[slot_idx] = layout_off;
+          layout_off += rdim_shared->constant_data_chunk_lane_counts[slot_idx];
         }
         chunk_idx += 1;
       }
@@ -2504,18 +2504,18 @@ rdim2_bake(Arena *arena, RDIM_BakeParams *params)
     // rjf: set up
     if(lane_idx() == lane_from_task_idx(0))
     {
-      rdim2_shared->baked_constants.constant_values_count = params->constants.total_count+1;
-      rdim2_shared->baked_constants.constant_values = push_array(arena, RDI_U32, rdim2_shared->baked_constants.constant_values_count);
+      rdim_shared->baked_constants.constant_values_count = params->constants.total_count+1;
+      rdim_shared->baked_constants.constant_values = push_array(arena, RDI_U32, rdim_shared->baked_constants.constant_values_count);
     }
     if(lane_idx() == lane_from_task_idx(1))
     {
-      rdim2_shared->baked_constants.constant_value_data_size = params->constants.total_value_data_size;
-      rdim2_shared->baked_constants.constant_value_data = push_array(arena, RDI_U8, rdim2_shared->baked_constants.constant_value_data_size);
+      rdim_shared->baked_constants.constant_value_data_size = params->constants.total_value_data_size;
+      rdim_shared->baked_constants.constant_value_data = push_array(arena, RDI_U8, rdim_shared->baked_constants.constant_value_data_size);
     }
     if(lane_idx() == lane_from_task_idx(2))
     {
-      rdim2_shared->baked_constants.constants_count = params->constants.total_count+1;
-      rdim2_shared->baked_constants.constants = push_array(arena, RDI_Constant, rdim2_shared->baked_constants.constants_count);
+      rdim_shared->baked_constants.constants_count = params->constants.total_count+1;
+      rdim_shared->baked_constants.constants = push_array(arena, RDI_Constant, rdim_shared->baked_constants.constants_count);
     }
     lane_sync();
     
@@ -2525,14 +2525,14 @@ rdim2_bake(Arena *arena, RDIM_BakeParams *params)
       for EachNode(n, RDIM_SymbolChunkNode, params->constants.first)
       {
         U64 slot_idx = lane_idx()*params->constants.chunk_count + chunk_idx;
-        U64 value_data_off = rdim2_shared->constant_data_chunk_lane_offs[slot_idx];
+        U64 value_data_off = rdim_shared->constant_data_chunk_lane_offs[slot_idx];
         Rng1U64 range = lane_range(n->count);
         for EachInRange(n_idx, range)
         {
           RDIM_Symbol *src = &n->v[n_idx];
-          RDI_Constant *dst = &rdim2_shared->baked_constants.constants[1 + n->base_idx + n_idx];
-          RDI_U32 *dst_value_off = &rdim2_shared->baked_constants.constant_values[1 + n->base_idx + n_idx];
-          RDI_U8 *dst_value_data = rdim2_shared->baked_constants.constant_value_data + value_data_off;
+          RDI_Constant *dst = &rdim_shared->baked_constants.constants[1 + n->base_idx + n_idx];
+          RDI_U32 *dst_value_off = &rdim_shared->baked_constants.constant_values[1 + n->base_idx + n_idx];
+          RDI_U8 *dst_value_data = rdim_shared->baked_constants.constant_value_data + value_data_off;
           dst->name_string_idx    = rdim_bake_idx_from_string(bake_strings, src->name);
           dst->type_idx           = (RDI_U32)rdim_idx_from_type(src->type); // TODO(rjf): @u64_to_u32
           dst->constant_value_idx = 1 + n->base_idx + n_idx;
@@ -2553,28 +2553,28 @@ rdim2_bake(Arena *arena, RDIM_BakeParams *params)
     //- rjf: setup outputs
     if(lane_idx() == lane_from_task_idx(0))
     {
-      rdim2_shared->baked_units.units_count = params->units.total_count+1;
-      rdim2_shared->baked_units.units = push_array(arena, RDI_Unit, rdim2_shared->baked_units.units_count);
+      rdim_shared->baked_units.units_count = params->units.total_count+1;
+      rdim_shared->baked_units.units = push_array(arena, RDI_Unit, rdim_shared->baked_units.units_count);
     }
     if(lane_idx() == lane_from_task_idx(1))
     {
-      rdim2_shared->baked_type_nodes.type_nodes_count = params->types.total_count+1;
-      rdim2_shared->baked_type_nodes.type_nodes = push_array(arena, RDI_TypeNode, rdim2_shared->baked_type_nodes.type_nodes_count);
+      rdim_shared->baked_type_nodes.type_nodes_count = params->types.total_count+1;
+      rdim_shared->baked_type_nodes.type_nodes = push_array(arena, RDI_TypeNode, rdim_shared->baked_type_nodes.type_nodes_count);
     }
     if(lane_idx() == lane_from_task_idx(2))
     {
-      rdim2_shared->baked_global_variables.global_variables_count = params->global_variables.total_count+1;
-      rdim2_shared->baked_global_variables.global_variables = push_array(arena, RDI_GlobalVariable, rdim2_shared->baked_global_variables.global_variables_count);
+      rdim_shared->baked_global_variables.global_variables_count = params->global_variables.total_count+1;
+      rdim_shared->baked_global_variables.global_variables = push_array(arena, RDI_GlobalVariable, rdim_shared->baked_global_variables.global_variables_count);
     }
     if(lane_idx() == lane_from_task_idx(3))
     {
-      rdim2_shared->baked_thread_variables.thread_variables_count = params->thread_variables.total_count+1;
-      rdim2_shared->baked_thread_variables.thread_variables = push_array(arena, RDI_ThreadVariable, rdim2_shared->baked_thread_variables.thread_variables_count);
+      rdim_shared->baked_thread_variables.thread_variables_count = params->thread_variables.total_count+1;
+      rdim_shared->baked_thread_variables.thread_variables = push_array(arena, RDI_ThreadVariable, rdim_shared->baked_thread_variables.thread_variables_count);
     }
     if(lane_idx() == lane_from_task_idx(4))
     {
-      rdim2_shared->baked_inline_sites.inline_sites_count = params->inline_sites.total_count+1;
-      rdim2_shared->baked_inline_sites.inline_sites = push_array(arena, RDI_InlineSite, rdim2_shared->baked_inline_sites.inline_sites_count);
+      rdim_shared->baked_inline_sites.inline_sites_count = params->inline_sites.total_count+1;
+      rdim_shared->baked_inline_sites.inline_sites = push_array(arena, RDI_InlineSite, rdim_shared->baked_inline_sites.inline_sites_count);
     }
     lane_sync();
     
@@ -2587,7 +2587,7 @@ rdim2_bake(Arena *arena, RDIM_BakeParams *params)
         for EachInRange(n_idx, range)
         {
           RDIM_Unit *src = &n->v[n_idx];
-          RDI_Unit *dst = &rdim2_shared->baked_units.units[n->base_idx + n_idx + 1];
+          RDI_Unit *dst = &rdim_shared->baked_units.units[n->base_idx + n_idx + 1];
           dst->unit_name_string_idx     = rdim_bake_idx_from_string(bake_strings, src->unit_name);
           dst->compiler_name_string_idx = rdim_bake_idx_from_string(bake_strings, src->compiler_name);
           dst->source_file_path_node    = rdim_bake_path_node_idx_from_string(path_tree, src->source_file);
@@ -2609,7 +2609,7 @@ rdim2_bake(Arena *arena, RDIM_BakeParams *params)
         for EachInRange(n_idx, range)
         {
           RDIM_Type *src = &n->v[n_idx];
-          RDI_TypeNode *dst = &rdim2_shared->baked_type_nodes.type_nodes[n->base_idx + n_idx + 1];
+          RDI_TypeNode *dst = &rdim_shared->baked_type_nodes.type_nodes[n->base_idx + n_idx + 1];
           
           //- rjf: fill shared type node info
           dst->kind      = src->kind;
@@ -2683,7 +2683,7 @@ rdim2_bake(Arena *arena, RDIM_BakeParams *params)
         for EachInRange(n_idx, range)
         {
           RDIM_Symbol *src = &n->v[n_idx];
-          RDI_GlobalVariable *dst = &rdim2_shared->baked_global_variables.global_variables[n->base_idx + n_idx + 1];
+          RDI_GlobalVariable *dst = &rdim_shared->baked_global_variables.global_variables[n->base_idx + n_idx + 1];
           dst->name_string_idx = rdim_bake_idx_from_string(bake_strings, src->name);
           dst->voff            = src->offset;
           dst->type_idx        = (RDI_U32)rdim_idx_from_type(src->type); // TODO(rjf): @u64_to_u32
@@ -2714,7 +2714,7 @@ rdim2_bake(Arena *arena, RDIM_BakeParams *params)
         for EachInRange(n_idx, range)
         {
           RDIM_Symbol *src = &n->v[n_idx];
-          RDI_ThreadVariable *dst = &rdim2_shared->baked_thread_variables.thread_variables[n->base_idx + n_idx + 1];
+          RDI_ThreadVariable *dst = &rdim_shared->baked_thread_variables.thread_variables[n->base_idx + n_idx + 1];
           dst->name_string_idx = rdim_bake_idx_from_string(bake_strings, src->name);
           dst->tls_off         = (RDI_U32)src->offset; // TODO(rjf): @u64_to_u32
           dst->type_idx        = (RDI_U32)rdim_idx_from_type(src->type);
@@ -2744,7 +2744,7 @@ rdim2_bake(Arena *arena, RDIM_BakeParams *params)
         Rng1U64 range = lane_range(n->count);
         for EachInRange(n_idx, range)
         {
-          RDI_InlineSite *dst = &rdim2_shared->baked_inline_sites.inline_sites[n->base_idx + n_idx + 1];
+          RDI_InlineSite *dst = &rdim_shared->baked_inline_sites.inline_sites[n->base_idx + n_idx + 1];
           RDIM_InlineSite *src = &n->v[n_idx];
           dst->name_string_idx   = rdim_bake_idx_from_string(bake_strings, src->name);
           dst->type_idx          = (RDI_U32)rdim_idx_from_type(src->type); // TODO(rjf): @u64_to_u32
@@ -2764,14 +2764,14 @@ rdim2_bake(Arena *arena, RDIM_BakeParams *params)
     // rjf: set up
     if(lane_idx() == 0)
     {
-      rdim2_shared->baked_file_paths.nodes_count = path_tree->count;
-      rdim2_shared->baked_file_paths.nodes = push_array(arena, RDI_FilePathNode, rdim2_shared->baked_file_paths.nodes_count);
-      rdim2_shared->baked_file_path_src_nodes = push_array(arena, RDIM_BakePathNode *, rdim2_shared->baked_file_paths.nodes_count);
+      rdim_shared->baked_file_paths.nodes_count = path_tree->count;
+      rdim_shared->baked_file_paths.nodes = push_array(arena, RDI_FilePathNode, rdim_shared->baked_file_paths.nodes_count);
+      rdim_shared->baked_file_path_src_nodes = push_array(arena, RDIM_BakePathNode *, rdim_shared->baked_file_paths.nodes_count);
       {
         U64 idx = 0;
         for(RDIM_BakePathNode *n = path_tree->first; n != 0; n = n->next_order)
         {
-          rdim2_shared->baked_file_path_src_nodes[idx] = n;
+          rdim_shared->baked_file_path_src_nodes[idx] = n;
           idx += 1;
         }
       }
@@ -2780,11 +2780,11 @@ rdim2_bake(Arena *arena, RDIM_BakeParams *params)
     
     // rjf: fill
     {
-      Rng1U64 range = lane_range(rdim2_shared->baked_file_paths.nodes_count);
+      Rng1U64 range = lane_range(rdim_shared->baked_file_paths.nodes_count);
       for EachInRange(idx, range)
       {
-        RDIM_BakePathNode *src = rdim2_shared->baked_file_path_src_nodes[idx];
-        RDI_FilePathNode *dst = &rdim2_shared->baked_file_paths.nodes[idx];
+        RDIM_BakePathNode *src = rdim_shared->baked_file_path_src_nodes[idx];
+        RDI_FilePathNode *dst = &rdim_shared->baked_file_paths.nodes[idx];
         dst->name_string_idx = rdim_bake_idx_from_string(bake_strings, src->name);
         dst->source_file_idx = rdim_idx_from_src_file(src->src_file);
         if(src->parent != 0)
@@ -2811,11 +2811,11 @@ rdim2_bake(Arena *arena, RDIM_BakeParams *params)
   {
     if(lane_idx() == lane_from_task_idx(0)) ProfScope("bake top level info")
     {
-      rdim2_shared->baked_top_level_info.top_level_info.arch                     = params->top_level_info.arch;
-      rdim2_shared->baked_top_level_info.top_level_info.exe_name_string_idx      = rdim_bake_idx_from_string(bake_strings, params->top_level_info.exe_name);
-      rdim2_shared->baked_top_level_info.top_level_info.exe_hash                 = params->top_level_info.exe_hash;
-      rdim2_shared->baked_top_level_info.top_level_info.voff_max                 = params->top_level_info.voff_max;
-      rdim2_shared->baked_top_level_info.top_level_info.producer_name_string_idx = rdim_bake_idx_from_string(bake_strings, params->top_level_info.producer_name);
+      rdim_shared->baked_top_level_info.top_level_info.arch                     = params->top_level_info.arch;
+      rdim_shared->baked_top_level_info.top_level_info.exe_name_string_idx      = rdim_bake_idx_from_string(bake_strings, params->top_level_info.exe_name);
+      rdim_shared->baked_top_level_info.top_level_info.exe_hash                 = params->top_level_info.exe_hash;
+      rdim_shared->baked_top_level_info.top_level_info.voff_max                 = params->top_level_info.voff_max;
+      rdim_shared->baked_top_level_info.top_level_info.producer_name_string_idx = rdim_bake_idx_from_string(bake_strings, params->top_level_info.producer_name);
     }
     if(lane_idx() == lane_from_task_idx(1)) ProfScope("bake binary sections")
     {
@@ -2833,8 +2833,8 @@ rdim2_bake(Arena *arena, RDIM_BakeParams *params)
         dst->foff_first      = src->foff_first;
         dst->foff_opl        = src->foff_opl;
       }
-      rdim2_shared->baked_binary_sections.binary_sections = dst_base;
-      rdim2_shared->baked_binary_sections.binary_sections_count = dst_idx;
+      rdim_shared->baked_binary_sections.binary_sections = dst_base;
+      rdim_shared->baked_binary_sections.binary_sections_count = dst_idx;
     }
   }
   lane_sync();
@@ -2844,29 +2844,29 @@ rdim2_bake(Arena *arena, RDIM_BakeParams *params)
   //
   RDIM_BakeResults result = {0};
   {
-    result.top_level_info         = rdim2_shared->baked_top_level_info;
-    result.binary_sections        = rdim2_shared->baked_binary_sections;
-    result.units                  = rdim2_shared->baked_units;
-    result.unit_vmap              = rdim2_shared->baked_unit_vmap;
-    result.src_files              = rdim2_shared->baked_src_files;
-    result.line_tables            = rdim2_shared->baked_line_tables;
-    result.type_nodes             = rdim2_shared->baked_type_nodes;
-    result.udts                   = rdim2_shared->baked_udts;
-    result.global_variables       = rdim2_shared->baked_global_variables;
-    result.global_vmap            = rdim2_shared->baked_global_vmap;
-    result.thread_variables       = rdim2_shared->baked_thread_variables;
-    result.constants              = rdim2_shared->baked_constants;
-    result.procedures             = rdim2_shared->baked_procedures;
-    result.scopes                 = rdim2_shared->baked_scopes;
-    result.inline_sites           = rdim2_shared->baked_inline_sites;
-    result.scope_vmap             = rdim2_shared->baked_scope_vmap;
-    result.top_level_name_maps    = rdim2_shared->baked_top_level_name_maps;
-    result.name_maps              = rdim2_shared->baked_name_maps;
-    result.file_paths             = rdim2_shared->baked_file_paths;
-    result.strings                = rdim2_shared->baked_strings;
-    result.idx_runs               = rdim2_shared->baked_idx_runs;
-    result.locations              = rdim2_shared->baked_locations;
-    result.location_blocks2       = rdim2_shared->baked_location_blocks;
+    result.top_level_info         = rdim_shared->baked_top_level_info;
+    result.binary_sections        = rdim_shared->baked_binary_sections;
+    result.units                  = rdim_shared->baked_units;
+    result.unit_vmap              = rdim_shared->baked_unit_vmap;
+    result.src_files              = rdim_shared->baked_src_files;
+    result.line_tables            = rdim_shared->baked_line_tables;
+    result.type_nodes             = rdim_shared->baked_type_nodes;
+    result.udts                   = rdim_shared->baked_udts;
+    result.global_variables       = rdim_shared->baked_global_variables;
+    result.global_vmap            = rdim_shared->baked_global_vmap;
+    result.thread_variables       = rdim_shared->baked_thread_variables;
+    result.constants              = rdim_shared->baked_constants;
+    result.procedures             = rdim_shared->baked_procedures;
+    result.scopes                 = rdim_shared->baked_scopes;
+    result.inline_sites           = rdim_shared->baked_inline_sites;
+    result.scope_vmap             = rdim_shared->baked_scope_vmap;
+    result.top_level_name_maps    = rdim_shared->baked_top_level_name_maps;
+    result.name_maps              = rdim_shared->baked_name_maps;
+    result.file_paths             = rdim_shared->baked_file_paths;
+    result.strings                = rdim_shared->baked_strings;
+    result.idx_runs               = rdim_shared->baked_idx_runs;
+    result.locations              = rdim_shared->baked_locations;
+    result.location_blocks2       = rdim_shared->baked_location_blocks;
   }
   
   return result;
diff --git a/src/rdi_make/rdi_make_local.h b/src/rdi_make/rdi_make_local.h
index e5b03675..9dfea4e2 100644
--- a/src/rdi_make/rdi_make_local.h
+++ b/src/rdi_make/rdi_make_local.h
@@ -62,8 +62,8 @@ struct RDIM_UnsortedJoinedLineTable
 
 //- rjf: shared state bundle
 
-typedef struct RDIM2_Shared RDIM2_Shared;
-struct RDIM2_Shared
+typedef struct RDIM_Shared RDIM_Shared;
+struct RDIM_Shared
 {
   RDI_U64 scope_vmap_count;
   RDIM_SortKey *scope_vmap_keys;
@@ -178,11 +178,11 @@ struct RDIM2_Shared
   RDIM_BinarySectionBakeResult baked_binary_sections;
 };
 
-global RDIM2_Shared *rdim2_shared = 0;
+global RDIM_Shared *rdim_shared = 0;
 
 internal RDIM_DataModel rdim_data_model_from_os_arch(OperatingSystem os, RDI_Arch arch);
 internal RDIM_TopLevelInfo rdim_make_top_level_info(String8 image_name, Arch arch, U64 exe_hash, RDIM_BinarySectionList sections);
-internal RDIM_BakeResults rdim2_bake(Arena *arena, RDIM_BakeParams *params);
+internal RDIM_BakeResults rdim_bake(Arena *arena, RDIM_BakeParams *params);
 internal RDIM_SerializedSectionBundle rdim_compress(Arena *arena, RDIM_SerializedSectionBundle *in);
 
 #endif // RDI_MAKE_LOCAL_H