Purge remaining port-batch markers missed by the phase cleanup

src/ast/expr.rs

@@ -282,11 +282,9 @@ impl Expr {
     }
 }
 
-// Expr — property/object/string accessor methods.
-// TODO(port): these call into `E::Object::as_property` / `EString`
-// methods that need `bun_core::utf16_eql_string`/`to_utf8_alloc` (track-A
-// blocked_on) and `Vec::deep_clone`. Types are real; bodies un-gate with
-// the parser round once those land.
+// Expr — property/object/string accessor methods. These call into
+// `E::Object::as_property` / `EString` methods backed by
+// `bun_core::utf16_eql_string` / `to_utf8_alloc` and `Vec::deep_clone`.
 
 impl Expr {
     pub fn has_any_property_named(&self, names: &'static [&'static [u8]]) -> bool {

src/ast/fold_string_addition.rs

@@ -3,9 +3,9 @@ use crate::{self as js_ast, E, Expr, StoreRef, e};
 use bun_alloc::Arena; // bumpalo::Bump re-export
 
 // ── local rope helpers ─────────────────────────────────────────────────────
-// `EString::push` / `EString::clone_rope_nodes` are still gated in E.rs
-// (round-C draft); inline the minimal surface here so this file can un-gate
-// without touching E.rs. These mirror the Zig bodies 1:1.
+// Mirrors the Zig `E.String.push` / `E.String.cloneRopeNodes` bodies 1:1.
+// `estring_push` takes the rope tail as a `StoreRef<EString>` (callers here
+// already hold one) instead of `&mut EString` like `EString::push` does.
 
 #[inline]
 fn store_append_string(s: E::EString) -> StoreRef<E::EString> {

src/bun_bin/Cargo.toml

@@ -30,7 +30,5 @@ bun_crash_handler.workspace = true
 bun_mimalloc_sys.workspace = true
 bun_platform.workspace = true
 
-# Phase-C: bun_runtime now compiles green; pulled in for `Cli::start()`.
-# bun_jsc remains gated until the JSC bridge links.
+# bun_runtime is pulled in for `Cli::start()`; bun_jsc comes in transitively.
 bun_runtime.workspace = true
-# bun_jsc.workspace = true

src/bun_bin/lib.rs

@@ -36,7 +36,7 @@
 
 use core::ffi::{c_char, c_int};
 
-mod phase_c_exports;
+mod link_exports;
 
 // Force-link `bun_platform` so its `#[no_mangle]` C exports
 // (`sys_epoll_pwait2`, `ioctl_ficlone`, …) reach the linker.

src/bun_bin/phase_c_exports.rs → src/bun_bin/link_exports.rs

@@ -1,4 +1,5 @@
-//! PHASE-C link bridge — **transient**, not a permanent grab-bag.
+//! Link-time `#[no_mangle]` export bridge — **transient**, not a permanent
+//! grab-bag.
 //!
 //! Every symbol that used to be stubbed here now has a real home (the `.rs`
 //! sibling of the Zig `export fn`) inside `bun_jsc` / `bun_runtime` /
@@ -18,7 +19,7 @@
 //!
 //! Calling convention: `jsc.conv` is plain `"C"` on every non-Windows-x64
 //! target, so `extern "C"` is correct on Linux/macOS. The Windows path is not
-//! exercised in Phase C.
+//! currently exercised here.
 
 #![allow(
     non_snake_case,
@@ -62,7 +63,7 @@ type VirtualMachine = c_void;
 // Real-body exports (no gated-crate dependency)
 // ════════════════════════════════════════════════════════════════════════════
 
-// PHASE-C: C++ callback — Zig: `pub export fn Bun__panic(msg, len) noreturn`
+// C++ callback — Zig: `pub export fn Bun__panic(msg, len) noreturn`
 // REAL: src/main.rs (binary-level export; defined here directly)
 #[unsafe(no_mangle)]
 pub extern "C" fn Bun__panic(msg: *const u8, len: usize) -> ! {
@@ -85,7 +86,7 @@ pub extern "C" fn Bun__panic(msg: *const u8, len: usize) -> ! {
 // Bun__NODE_NO_WARNINGS
 
 // REAL: `Bun__getTLSRejectUnauthorizedValue` / `Bun__isNoProxy` now exported
-// directly from `bun_jsc::virtual_machine_exports` (un-gated in phase-d).
+// directly from `bun_jsc::virtual_machine_exports`.
 
 // REAL: now provided by bun_runtime (src/runtime/napi/napi_body.rs).
 // napi_internal_suppress_crash_on_abort_if_desired

src/bun_core/Progress.rs

@@ -63,8 +63,8 @@ unsafe extern "system" {
 
 // Progress's terminal handle is the canonical `output::File` (vtable-backed
 // stderr/File from `OutputSinkVTable`). The duplicate `ProgressTerminalVTable`
-// from B-0 round 1 is removed; tty/ansi/winsize route through the new
-// `OutputSinkVTable` slots so `bun_core` stays T0 (no `bun_sys` dep).
+// was removed; tty/ansi/winsize route through the `OutputSinkVTable` slots so
+// `bun_core` stays T0 (no `bun_sys` dep).
 use crate::Fd;
 pub use crate::output::File;
 use crate::output::output_sink;

src/bun_core/string/mod.rs

@@ -2734,7 +2734,7 @@ pub use wtf::parse_double;
 ///
 /// Unlike `Cell<String>`, [`set`] derefs the previous value and [`replace`]
 /// returns an [`OwnedString`] — so the only way to leak a refcount is to
-/// `mem::forget` the cell or its `replace` result. The R-2 `&self` migrations
+/// `mem::forget` the cell or its `replace` result. The `&self` migrations
 /// introduced `Cell<String>::set(..)` calls that silently leaked the old +1.
 ///
 /// [`get`] returns a bitwise `String` copy with **borrow** semantics (no ref

src/bundler/Cargo.toml

@@ -27,10 +27,7 @@ bumpalo.workspace = true
 typed-arena.workspace = true
 bun_base64.workspace = true
 bun_alloc.workspace = true
-# TODO(b2-blocked): bun_analytics — adding the dep triggers a fresh build of
-# upstream crates (css/logger/js_parser) with in-progress breakage. Re-add once
-# the tree is green; usages in options.rs are gated or stubbed locally.
-# bun_analytics.workspace = true
+bun_analytics.workspace = true
 bun_resolver.workspace = true
 # `bun_resolve_builtins` only depends on `bun_options_types` + `bun_string`
 # (both already in this graph), so no cycle.

src/bundler/LinkerContext.rs

@@ -60,10 +60,10 @@ bun_core::declare_scope!(LinkerCtx, visible);
 bun_core::declare_scope!(TreeShake, hidden);
 
 // ══════════════════════════════════════════════════════════════════════════
-// CYCLEBREAK(b0): vtable instance for `bun_crash_handler::BundleGenerateChunkVTable`
-// (cold-path §Dispatch — crash trace only). crash_handler (T1) holds erased
-// `(*const LinkerContext, *const Chunk, *const PartRange)`; bundler supplies
-// the formatter that knows their layout. Mirrors src/crash_handler/crash_handler.zig:135.
+// Vtable instance for `bun_crash_handler::BundleGenerateChunkVTable` (cold
+// path — crash trace only). `crash_handler` holds erased `(*const
+// LinkerContext, *const Chunk, *const PartRange)`; the bundler supplies the
+// formatter that knows their layout. Mirrors src/crash_handler/crash_handler.zig:135.
 // ══════════════════════════════════════════════════════════════════════════
 #[cfg(feature = "show_crash_trace")]
 bun_crash_handler::link_impl_BundleGenerateChunkCtx! {

src/bundler/ParseTask.rs

@@ -488,11 +488,6 @@ export var __callDispose = (stack, error, hasError) => {
 
 // ══════════════════════════════════════════════════════════════════════════
 // Per-file parse worker — `getAST`/`getCodeForParseTask`/`runFromThreadPool`.
-// The struct/FFI surface and `get_runtime_source` are real. Bodies
-// that touch the still-gated `crate::ThreadPool` Worker module or the opaque
-// `JSBundlerPlugin`/`FileMap` forward-decls remain ``-gated
-// per-function below with explicit `// blocked_on:` notes; they un-gate by
-// deletion once those modules land.
 // ══════════════════════════════════════════════════════════════════════════
 pub mod parse_worker {
     use super::*;

src/bundler/ThreadPool.rs

@@ -639,8 +639,7 @@ impl Worker {
             // PORT NOTE: `MimallocArena::help_catch_memory_issues` collected
             // mimalloc's deferred frees + zero-filled freed pages. The Rust
             // arena is `bumpalo::Bump`, which has no equivalent — calls
-            // dropped, gated on the real `MimallocArena` un-gate
-            // (`bun_alloc/MimallocArena.rs` is ``).
+            // dropped, gated on the real `MimallocArena` un-gate.
         }
 
         worker

src/bundler/bundle_v2.rs

@@ -367,10 +367,10 @@ pub mod bv2_impl {
     use bun_resolver::fs::PathResolverExt as _;
     use bun_resolver::{self as _resolver, Resolver, is_package_path};
     use bun_threading::ThreadPool as ThreadPoolLib;
-    // TODO(b0): bake_types arrives from move-in (TYPE_ONLY Side/Graph/BuiltInModule/Framework → bundler)
+    // TODO(port): bake_types arrives from move-in (TYPE_ONLY Side/Graph/BuiltInModule/Framework → bundler)
     use self::bake_types as bake;
 
-    /// CYCLEBREAK(b0) TYPE_ONLY: pure value types from bake that bundler needs without
+    /// CYCLEBREAK TYPE_ONLY: pure value types from bake that bundler needs without
     /// depending on the full DevServer. Move-in pass keeps these as the canonical defs;
     /// bun_bake (post tier-6 collapse: bun_runtime::bake) re-exports from here.
     pub mod bake_types {
@@ -492,7 +492,7 @@ pub mod bv2_impl {
             /// In Zig this lives on the legacy package_json `Framework`; the duck-typed
             /// `comptime TranspilerType` callers reach it through `options.framework.?`.
             pub client_css_in_js: crate::options::ClientCssInJs,
-            // TODO(b0-genuine): remaining Framework field `file_system_router_types`
+            // TODO(port): remaining Framework field `file_system_router_types`
             // stays in T6; only bake::FrameworkRouter reads it.
             _opaque_tail: (),
         }
@@ -739,10 +739,10 @@ pub mod bv2_impl {
             }
         }
     }
-    // TODO(b0): jsc::api arrives from move-in (TYPE_ONLY → bundler)
+    // TODO(port): jsc::api arrives from move-in (TYPE_ONLY → bundler)
     use self::api as jsc_api;
 
-    /// CYCLEBREAK(b0) TYPE_ONLY: data-only halves of `jsc::api::JSBundler` and
+    /// CYCLEBREAK TYPE_ONLY: data-only halves of `jsc::api::JSBundler` and
     /// `jsc::api::BuildArtifact` that the bundler reads/constructs without touching
     /// JSC. The JS-thread halves (dispatch onto the JS event loop, `toJS`, plugin
     /// FFI bodies) stay in tier-6 (`bun_runtime::api`) and re-export these.
@@ -5229,7 +5229,7 @@ pub mod bv2_impl {
             Ok(ctx)
         }
 
-        // TODO(b0-genuine): body has deep DevServer field access (current_bundle.start_data,
+        // TODO(port): body has deep DevServer field access (current_bundle.start_data,
         // css_entry_points, etc.). After tier-6 collapse this fn should be HOISTED into
         // bun_runtime::bake (which can name DevServer concretely) and call back into BundleV2
         // helpers. Until then the entry-point fields are reached through the vtable.

src/bundler/cache.rs

@@ -9,19 +9,19 @@ use bun_parsers::json_parser;
 use bun_resolver::fs as fs_mod;
 use bun_sys::{self, Fd};
 
-// B-3 UNIFIED: `Define` is now the single canonical `bun_js_parser::defines::Define`
-// (re-exported via `crate::defines`); `JavaScript::parse`/`scan` and the bundler's
+// `Define` is the single canonical `bun_js_parser::defines::Define` (re-exported
+// via `crate::defines`); `JavaScript::parse`/`scan` and the bundler's
 // `BundleOptions.define` share the same nominal type.
 use js_parser::defines::Define;
 
 // ══════════════════════════════════════════════════════════════════════════
-// B-3 UNIFIED: `RuntimeTranspilerCache` is canonical in `bun_js_parser`
-// (lower tier) so `Features.runtime_transpiler_cache: Option<*mut RTC>` and
+// `RuntimeTranspilerCache` is canonical in `bun_ast` (a lower-tier crate)
+// so `Features.runtime_transpiler_cache: Option<*mut RTC>` and
 // `ParseOptions.runtime_transpiler_cache: Option<&mut RTC>` are the same
 // nominal type. This crate adds the env-var-gated `disabled`/`set_disabled` via
-// the `RuntimeTranspilerCacheExt` trait below — those need `bun_core::env_var`
-// which sits a tier above js_parser. `Entry` / `Metadata` stay concrete here;
-// the canonical
+// the `RuntimeTranspilerCacheExt` trait below; the disk-I/O / `js_printer`
+// dispatch also lives here because it needs `bun_js_printer`, which sits a
+// tier above `bun_ast`. `Entry` / `Metadata` stay concrete here; the canonical
 // struct stores them type-erased as `*mut ()`.
 // ══════════════════════════════════════════════════════════════════════════
 use bun_ast::RuntimeTranspilerCache;
@@ -37,7 +37,7 @@ pub const RUNTIME_TRANSPILER_CACHE_VERSION: u32 = 20;
 pub static DISABLED: AtomicBool = AtomicBool::new(false);
 
 /// Extension surface for the canonical `RuntimeTranspilerCache` (defined in
-/// `bun_js_parser`). Separate trait so the env-var-dependent bodies stay in
+/// `bun_ast`). Separate trait so the env-var-dependent bodies stay in
 /// this crate without an orphan-rule violation.
 pub trait RuntimeTranspilerCacheExt {
     /// Mirrors the Zig `pub var is_disabled` namespaced const — kept as an

src/bundler/defines.rs

@@ -12,7 +12,7 @@ use crate::defines_table::{
 };
 
 // ══════════════════════════════════════════════════════════════════════════
-// B-3 UNIFIED: `Define` / `DefineData` / `DotDefine` / `Flags` / `Options` /
+// `Define` / `DefineData` / `DotDefine` / `Flags` / `Options` /
 // `RawDefines` / `UserDefines` / `UserDefinesArray` are canonical in
 // `bun_js_parser::defines` (lower tier) so the parser's `P.define: &'a Define`
 // and `BundleOptions.define: Box<Define>` are the *same* nominal type. This

src/bundler/linker.rs

@@ -12,7 +12,7 @@ use bun_paths::{self, SEP};
 // PORT NOTE: two `fs` shapes are in play here. `bun_resolver::fs` (`Fs`) holds
 // the singleton `FileSystem` / `DirnameStore`; `bun_paths::fs` (`PFs`) defines
 // the `Path`/`PathName` value types that `ImportRecord.path` is typed against.
-// Both port `src/resolver/fs.zig`; B-3 collapses them. Until then, construct
+// Both port `src/resolver/fs.zig`; until they are unified, construct
 // `import_record.path` via `PFs::Path` so the field assignment unifies.
 use bun_core::strings;
 use bun_paths::fs as PFs;

src/bundler/linker_context/scanImportsAndExports.rs

@@ -799,8 +799,8 @@ pub fn scan_imports_and_exports(
                         dependencies.push(Dependency {
                             // PORT NOTE: `crate::Index` ↔ `bun_ast::Index` are both
                             // `#[repr(transparent)] u32` newtypes ported from the
-                            // same Zig `ast.Index`; bridge by `.value` until B-3
-                            // collapses them to a single re-export.
+                            // same Zig `ast.Index`; bridge through the inner u32
+                            // until they are collapsed to a single re-export.
                             source_index: bun_ast::Index(target_source_index.get()),
                             part_index: *part_index,
                         });